| 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.EClassNamesMatch; |
| import org.eclipse.viatra.query.application.queries.util.EClassNamesQuerySpecification; |
| 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.eClassNames 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 EClassNamesMatch}. |
| * |
| * <p>Original source: |
| * <code><pre> |
| * pattern eClassNames(c: EClass, n : EString)= { |
| * EClass.name(c,n); |
| * } |
| * </pre></code> |
| * |
| * @see EClassNamesMatch |
| * @see EClassNamesProcessor |
| * @see EClassNamesQuerySpecification |
| * |
| */ |
| @SuppressWarnings("all") |
| public class EClassNamesMatcher extends BaseMatcher<EClassNamesMatch> { |
| /** |
| * 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 EClassNamesMatcher on(final ViatraQueryEngine engine) throws ViatraQueryException { |
| // check if matcher already exists |
| EClassNamesMatcher matcher = engine.getExistingMatcher(querySpecification()); |
| if (matcher == null) { |
| matcher = new EClassNamesMatcher(engine); |
| // do not have to "put" it into engine.matchers, reportMatcherInitialized() will take care of it |
| } |
| return matcher; |
| } |
| |
| private final static int POSITION_C = 0; |
| |
| private final static int POSITION_N = 1; |
| |
| private final static Logger LOGGER = ViatraQueryLoggingUtil.getLogger(EClassNamesMatcher.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 EClassNamesMatcher(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 EClassNamesMatcher(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 pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, or null if not bound. |
| * @return matches represented as a EClassNamesMatch object. |
| * |
| */ |
| public Collection<EClassNamesMatch> getAllMatches(final EClass pC, final String pN) { |
| return rawGetAllMatches(new Object[]{pC, pN}); |
| } |
| |
| /** |
| * 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 pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, or null if not bound. |
| * @return a match represented as a EClassNamesMatch object, or null if no match is found. |
| * |
| */ |
| public EClassNamesMatch getOneArbitraryMatch(final EClass pC, final String pN) { |
| return rawGetOneArbitraryMatch(new Object[]{pC, pN}); |
| } |
| |
| /** |
| * 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 pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, or null if not bound. |
| * @return true if the input is a valid (partial) match of the pattern. |
| * |
| */ |
| public boolean hasMatch(final EClass pC, final String pN) { |
| return rawHasMatch(new Object[]{pC, pN}); |
| } |
| |
| /** |
| * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters. |
| * @param pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, or null if not bound. |
| * @return the number of pattern matches found. |
| * |
| */ |
| public int countMatches(final EClass pC, final String pN) { |
| return rawCountMatches(new Object[]{pC, pN}); |
| } |
| |
| /** |
| * Executes the given processor on each match of the pattern that conforms to the given fixed values of some parameters. |
| * @param pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, or null if not bound. |
| * @param processor the action that will process each pattern match. |
| * |
| */ |
| public void forEachMatch(final EClass pC, final String pN, final IMatchProcessor<? super EClassNamesMatch> processor) { |
| rawForEachMatch(new Object[]{pC, pN}, 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 pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, 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 pC, final String pN, final IMatchProcessor<? super EClassNamesMatch> processor) { |
| return rawForOneArbitraryMatch(new Object[]{pC, pN}, 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 pC the fixed value of pattern parameter c, or null if not bound. |
| * @param pN the fixed value of pattern parameter n, or null if not bound. |
| * @return the (partial) match object. |
| * |
| */ |
| public EClassNamesMatch newMatch(final EClass pC, final String pN) { |
| return EClassNamesMatch.newMatch(pC, pN); |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for c. |
| * @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> rawAccumulateAllValuesOfc(final Object[] parameters) { |
| Set<EClass> results = new HashSet<EClass>(); |
| rawAccumulateAllValues(POSITION_C, parameters, results); |
| return results; |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for c. |
| * @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> getAllValuesOfc() { |
| return rawAccumulateAllValuesOfc(emptyArray()); |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for c. |
| * @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> getAllValuesOfc(final EClassNamesMatch partialMatch) { |
| return rawAccumulateAllValuesOfc(partialMatch.toArray()); |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for c. |
| * @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> getAllValuesOfc(final String pN) { |
| return rawAccumulateAllValuesOfc(new Object[]{ |
| null, |
| pN |
| }); |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for n. |
| * @return the Set of all values, null if no parameter with the given name exists, empty set if there are no matches |
| * |
| */ |
| protected Set<String> rawAccumulateAllValuesOfn(final Object[] parameters) { |
| Set<String> results = new HashSet<String>(); |
| rawAccumulateAllValues(POSITION_N, parameters, results); |
| return results; |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for n. |
| * @return the Set of all values, null if no parameter with the given name exists, empty set if there are no matches |
| * |
| */ |
| public Set<String> getAllValuesOfn() { |
| return rawAccumulateAllValuesOfn(emptyArray()); |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for n. |
| * @return the Set of all values, null if no parameter with the given name exists, empty set if there are no matches |
| * |
| */ |
| public Set<String> getAllValuesOfn(final EClassNamesMatch partialMatch) { |
| return rawAccumulateAllValuesOfn(partialMatch.toArray()); |
| } |
| |
| /** |
| * Retrieve the set of values that occur in matches for n. |
| * @return the Set of all values, null if no parameter with the given name exists, empty set if there are no matches |
| * |
| */ |
| public Set<String> getAllValuesOfn(final EClass pC) { |
| return rawAccumulateAllValuesOfn(new Object[]{ |
| pC, |
| null |
| }); |
| } |
| |
| @Override |
| protected EClassNamesMatch tupleToMatch(final Tuple t) { |
| try { |
| return EClassNamesMatch.newMatch((EClass) t.get(POSITION_C), (String) t.get(POSITION_N)); |
| } catch(ClassCastException e) { |
| LOGGER.error("Element(s) in tuple not properly typed!",e); |
| return null; |
| } |
| } |
| |
| @Override |
| protected EClassNamesMatch arrayToMatch(final Object[] match) { |
| try { |
| return EClassNamesMatch.newMatch((EClass) match[POSITION_C], (String) match[POSITION_N]); |
| } catch(ClassCastException e) { |
| LOGGER.error("Element(s) in array not properly typed!",e); |
| return null; |
| } |
| } |
| |
| @Override |
| protected EClassNamesMatch arrayToMatchMutable(final Object[] match) { |
| try { |
| return EClassNamesMatch.newMutableMatch((EClass) match[POSITION_C], (String) match[POSITION_N]); |
| } 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<EClassNamesMatcher> querySpecification() throws ViatraQueryException { |
| return EClassNamesQuerySpecification.instance(); |
| } |
| } |