| /******************************************************************************* |
| * Copyright (c) 2007, 2008, 2009 THALES GLOBAL SERVICES. |
| * 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: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.sirius.query.legacy.business.internal.interpreter; |
| |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.WeakHashMap; |
| |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.impl.DynamicEObjectImpl; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.ECrossReferenceAdapter; |
| import org.eclipse.sirius.common.tools.api.contentassist.ContentContext; |
| import org.eclipse.sirius.common.tools.api.contentassist.ContentInstanceContext; |
| import org.eclipse.sirius.common.tools.api.contentassist.ContentProposal; |
| import org.eclipse.sirius.common.tools.api.contentassist.IProposalProvider; |
| import org.eclipse.sirius.common.tools.api.interpreter.EvaluationException; |
| import org.eclipse.sirius.common.tools.api.interpreter.IInterpreter; |
| import org.eclipse.sirius.common.tools.api.interpreter.IInterpreterProvider; |
| import org.eclipse.sirius.common.tools.api.interpreter.IVariableStatusListener; |
| import org.eclipse.sirius.ecore.extender.business.api.accessor.MetamodelDescriptor; |
| import org.eclipse.sirius.ecore.extender.business.api.accessor.ModelAccessor; |
| import org.eclipse.sirius.ext.base.collect.StackEx; |
| import org.eclipse.sirius.query.legacy.AcceleoInterpreterPlugin; |
| import org.eclipse.sirius.query.legacy.ecore.factories.FactoryException; |
| import org.eclipse.sirius.query.legacy.gen.template.Template; |
| import org.eclipse.sirius.query.legacy.gen.template.TemplateConstants; |
| import org.eclipse.sirius.query.legacy.gen.template.TemplateElement; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENode; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeCastException; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeException; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeIterator; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeList; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.LaunchManager; |
| import org.eclipse.sirius.query.legacy.gen.template.scripts.SpecificScript; |
| import org.eclipse.sirius.query.legacy.tools.classloaders.AcceleoClassLoader; |
| |
| /** |
| * This utility class ease the evaluation of Acceleo expressions. A singleton |
| * instance is available for pure API comfort but it is advised for performances |
| * issues to avoid changing metamodel on consecutive evaluations. |
| * |
| * @author cbrun |
| * |
| */ |
| // CHECKSTYLE:OFF |
| public abstract class AcceleoInterpreter implements IInterpreter, IInterpreterProvider, IProposalProvider { |
| // CHECKSTYLE:ON |
| /** |
| * Keyword used to identify a variable. |
| */ |
| protected static final String VARIABLE_KEYWORD = "$"; |
| |
| /** |
| * Keyword used to identify the start of an expression. |
| */ |
| protected static final String PREFIX_KEYWORD = "<%"; |
| |
| /** |
| * Keyword used to identify the end of an expression. |
| */ |
| protected static final String SUFFIX_KEYWORD = "%>"; |
| |
| /** This will allow us to store the parsed templates for each expressions. */ |
| protected final Map<SpecificScript, Map<String, Template>> templates = new HashMap<SpecificScript, Map<String, Template>>(); |
| |
| /** |
| * Script instance. |
| */ |
| protected SpecificScript pvScript; |
| |
| /** |
| * Table keeping track of the variables values. |
| */ |
| protected final Map<String, StackEx<ENode>> variableTables = new HashMap<String, StackEx<ENode>>(); |
| |
| /** |
| * Map used to keep track of the Scripts instances from a metamodel URI. |
| */ |
| protected Map<String, SpecificScript> mmToScript = new WeakHashMap<String, SpecificScript>(); |
| |
| private final Collection<String> imports = new LinkedHashSet<String>(); |
| |
| private final Set<IVariableStatusListener> variablesListeners = new HashSet<IVariableStatusListener>(); |
| |
| /** The optional cache. */ |
| private Map<CacheKey, ENode> cache; |
| |
| private AcceleoTemplateWorkspaceListener templateListener; |
| |
| /** |
| * Constructor. |
| */ |
| public AcceleoInterpreter() { |
| installWorkspaceListener(); |
| } |
| |
| /** |
| * Return a script able to evaluate expression on the given EObject. |
| * |
| * @param current |
| * current {@link EObject}. |
| * @return a script able to evaluate expression on the given EObject. |
| */ |
| protected final SpecificScript getScript(final EObject current) { |
| /* |
| * we keep one script per metamodel. |
| */ |
| final String mmURI = computeMetamodelURI(current); |
| final SpecificScript resultScript = mmToScript.get(mmURI); |
| if (resultScript != null) |
| return resultScript; |
| final SpecificScript newScript = createNewScript(current, mmURI); |
| mmToScript.put(mmURI, newScript); |
| return newScript; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| */ |
| protected abstract SpecificScript createNewScript(final EObject current, final String mmURI); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluate(org.eclipse.emf.ecore.EObject, |
| * java.lang.String) |
| */ |
| public Object evaluate(final EObject target, final String expression) throws EvaluationException { |
| final ENode node = evaluateENode(target, expression); |
| return getValue(node, expression); |
| } |
| |
| /** |
| * Evaluate the given expression and return the result. |
| * |
| * @param eObj |
| * : the EObject on which we want to apply the evaluation. |
| * @param expression |
| * : the Acceleo expression to evaluate, something like |
| * "<%eContainer()%>" but may also be "name : <%name%>". |
| * @return : the {@link ENode} corresponding to this evaluation, and |
| * {@link ENode} wrap any possible type Acceleo may use. |
| * @throws EvaluationException |
| * on evaluation errors. |
| */ |
| public ENode evaluateENode(final EObject eObj, final String expression) throws EvaluationException { |
| try { |
| /* |
| * We need to set the preferred loader here in order |
| * to have Acceleo use the same class loader to create and evaluate |
| * the script so as to avoid LinkageErrors. It will be reverted back |
| * to null post-evaluation. IMPORTANT : the preferred class loader |
| * MUST be set everywhere we instantiate or evaluate a |
| * SpecificScript. See |
| * AcceleoExtendedInterpreter#createNewScript(EObject, String) and |
| * SiriusInformationAdapter#getAdapter(Object, Class). |
| */ |
| AcceleoClassLoader.setPreferredClassLoader(eObj.getClass().getClassLoader()); |
| final SpecificScript script = getScript(eObj); |
| Template template = null; |
| if (expression != null && expression.trim().length() > 0) { |
| Map<String, Template> scriptTemplates = templates.get(script); |
| if (scriptTemplates != null && scriptTemplates.containsKey(expression)) { |
| template = scriptTemplates.get(expression); |
| } else { |
| template = Template.from(expression, script, eObj); |
| if (scriptTemplates == null) { |
| scriptTemplates = new WeakHashMap<String, Template>(); |
| templates.put(script, scriptTemplates); |
| } |
| scriptTemplates.put(expression, template); |
| } |
| } |
| if (template != null) |
| return template.evaluate(eObj, LaunchManager.create("run", false)); |
| AcceleoClassLoader.setPreferredClassLoader(null); |
| return new ENode(null, (TemplateElement) null, true); |
| } catch (final ENodeException e) { |
| throw new EvaluationException(e); |
| } catch (final FactoryException e) { |
| throw new EvaluationException(e); |
| } |
| } |
| |
| /** |
| * Evaluate an acceleo condition. The result is <code>true</code> if the |
| * evaluation returns a <code>true</code> value or if the evaluation returns |
| * a non null object. If the condition is null or empty or only composed |
| * with white spaces, the result is <code>true</code>. |
| * |
| * @param eObj |
| * the context object. |
| * @param condition |
| * the condition to test. |
| * @return <code>true</code> if the evaluation returns a <code>true</code> |
| * value or if the evaluation returns a non null object or if the |
| * condition is empty. |
| * @throws EvaluationException |
| * if the interpreter encounter a problem while evaluting the |
| * condition. |
| * @deprecated use {@link AcceleoInterpreter#evaluate(EObject, String)} |
| * instead |
| */ |
| @Deprecated |
| public boolean evaluateCondition(final EObject eObj, final String condition) throws EvaluationException { |
| final boolean preconditionAccepted = true; |
| return preconditionAccepted; |
| } |
| |
| /** |
| * return the header of the script containing the imports. |
| * |
| * @param metamodelURI |
| * the metamodel uri. |
| * @return the header of the script containing the imports. |
| */ |
| protected String getScriptHeader(final String metamodelURI) { |
| final String carriage = "\n"; |
| final StringBuffer header = new StringBuffer(""); |
| header.append(TemplateConstants.IMPORT_BEGIN).append(carriage); |
| header.append(TemplateConstants.MODELTYPE_WORD).append(' ').append(metamodelURI).append(" \n"); |
| final Iterator<String> it = imports.iterator(); |
| while (it.hasNext()) { |
| final String imp = it.next(); |
| if (!imp.contains("::")) { |
| // Don't try to import Acceleo 3 modules. |
| header.append(TemplateConstants.IMPORT_WORD).append(' ').append(imp).append(carriage); |
| } |
| } |
| header.append(carriage).append(TemplateConstants.IMPORT_END); |
| return header.toString(); |
| } |
| |
| /** |
| * Gets the URI of the metamodel that defines the given object. |
| * |
| * @param object |
| * is an object of the model |
| * @return the URI of the metamodel |
| */ |
| protected String computeMetamodelURI(final EObject object) { |
| if (isDynamic(object)) { |
| return computeEcoreFileURI(object); |
| } else { |
| return computeNsURI(object); |
| } |
| } |
| |
| private String computeEcoreFileURI(final EObject object) { |
| final Resource eCoreRes = object.eClass().eResource(); |
| if (eCoreRes != null && eCoreRes.getURI() != null) { |
| final URI ecoreURI = eCoreRes.getURI(); |
| if (ecoreURI.isPlatformResource()) { |
| return ecoreURI.toPlatformString(true); |
| } |
| } |
| return null; |
| } |
| |
| private boolean isDynamic(final EObject object) { |
| return object instanceof DynamicEObjectImpl; |
| } |
| |
| private String computeNsURI(final EObject object) { |
| EPackage p = object.eClass().getEPackage(); |
| String nsURI = p.getNsURI(); |
| p = p.getESuperPackage(); |
| while (p != null) { |
| final String currentURI = p.getNsURI(); |
| if (currentURI != null && currentURI.length() > 0 && !currentURI.startsWith("unused://")) { |
| nsURI = currentURI; |
| } |
| p = p.getESuperPackage(); |
| } |
| return nsURI; |
| } |
| |
| /** |
| * Set a variable in the current interpreter. The user will be able to |
| * access the variable value using the "$" prefix. |
| * |
| * @param name |
| * the variable name. |
| * @param value |
| * the variable value. |
| */ |
| public void setVariable(final String name, final EObject value) { |
| setVariable(name, new ENode(value, (TemplateElement) null, true)); |
| } |
| |
| /** |
| * Set a variable in the current interpreter. The user will be able to |
| * access the variable value using the "$" prefix. |
| * |
| * @param name |
| * the variable name. |
| * @param value |
| * the variable value. |
| */ |
| public void setVariable(final String name, final Object value) { |
| final ENode valueNode = ENode.createTry(value, new ENode(null, (TemplateElement) null, true)); |
| setVariable(name, valueNode); |
| } |
| |
| /** |
| * Set a variable in the current interpreter. The user will be able to |
| * access the variable value using the "$" prefix. |
| * |
| * @param name |
| * the variable name. |
| * @param value |
| * the variable value. |
| */ |
| public void setVariable(final String name, final ENode value) { |
| StackEx<ENode> values = variableTables.get(name); |
| if (values == null) { |
| values = new StackEx<ENode>(); |
| } |
| values.push(value); |
| variableTables.put(name, values); |
| notifyVariableListeners(); |
| } |
| |
| /** |
| * Unset the variable. |
| * |
| * @param name |
| * the variable name. |
| */ |
| public void unSetVariable(final String name) { |
| final StackEx<ENode> values = variableTables.get(name); |
| if (values != null) { |
| if (values.size() > 1) { |
| /* |
| * There is another value in the stack, let's pop the old one. |
| */ |
| values.pop(); |
| } else { |
| /* |
| * It was the last value in the stack, let's clear this variable |
| * entry. |
| */ |
| clearVariable(name); |
| } |
| } |
| notifyVariableListeners(); |
| } |
| |
| /** |
| * return the variable value. |
| * |
| * @param name |
| * the variable name. |
| * @return the variable value. |
| */ |
| protected ENode getVariableValue(final String name) { |
| final StackEx<ENode> values = variableTables.get(name); |
| if (values != null) |
| return values.peek(); |
| return null; |
| } |
| |
| /** |
| * Check if the variable is set. |
| * |
| * @param name |
| * the variable name |
| * @return <code>true</code> is the variable is set, <code>false</code> |
| * otherwise |
| */ |
| protected boolean isVariableSet(final String name) { |
| return variableTables.containsKey(name); |
| } |
| |
| /** |
| * Clear all the variables of the interpreter. |
| */ |
| public void clearVariables() { |
| variableTables.clear(); |
| notifyVariableListeners(); |
| } |
| |
| /** |
| * Clear the variable with the given name. |
| * |
| * @param name |
| * : name of the variable to clear. |
| */ |
| public void clearVariable(final String name) { |
| if (variableTables.containsKey(name)) { |
| variableTables.remove(name); |
| notifyVariableListeners(); |
| } |
| } |
| |
| /** |
| * Clear all the imports. |
| */ |
| public void clearImports() { |
| mmToScript.clear(); |
| templates.clear(); |
| imports.clear(); |
| } |
| |
| /** |
| * Import a Java service or a template in the current Interpreter. |
| * |
| * @param path |
| * the import id, for instance |
| * <tt>fr.obeo.my.package.java.StringServices</tt> |
| */ |
| public void addImport(final String path) { |
| if (path != null && path.contains(".") && !imports.contains(path)) { |
| mmToScript.clear(); |
| templates.clear(); |
| imports.add(path); |
| } |
| templates.clear(); |
| } |
| |
| /** |
| * Add a new listener to the current interpreter, the listener will be |
| * notified on changes concerning variables. |
| * |
| * @param newListener |
| * the new listener to add. |
| */ |
| public void addVariableStatusListener(final IVariableStatusListener newListener) { |
| variablesListeners.add(newListener); |
| } |
| |
| /** |
| * Remove the given {@link IVariableStatusListener}. |
| * |
| * @param listener |
| * listener to remove. |
| */ |
| public void removeVariableStatusListener(final IVariableStatusListener listener) { |
| variablesListeners.remove(listener); |
| } |
| |
| /** |
| * Map with the variables. |
| * |
| * @return a map containing the current variables. |
| */ |
| public Map<String, ?> getVariables() { |
| final Map<String, ENode> lightVariables = new HashMap<String, ENode>(); |
| final Iterator<String> it = variableTables.keySet().iterator(); |
| while (it.hasNext()) { |
| final String variableName = it.next(); |
| lightVariables.put(variableName, getVariableValue(variableName)); |
| } |
| return lightVariables; |
| } |
| |
| private void notifyVariableListeners() { |
| if (variablesListeners.size() > 0) { |
| final Map<String, ?> lightVariables = getVariables(); |
| final Iterator<IVariableStatusListener> it = variablesListeners.iterator(); |
| while (it.hasNext()) { |
| final IVariableStatusListener listener = it.next(); |
| listener.notifyChanged(lightVariables); |
| } |
| } |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateBoolean(EObject, |
| * String) |
| */ |
| @Deprecated |
| public boolean getAsBoolean(final Object evaluate) { |
| return internalGetAsBoolean(evaluate); |
| } |
| |
| private boolean internalGetAsBoolean(final Object evaluate) { |
| boolean result = false; |
| if (evaluate instanceof ENode) { |
| result = ENodeHelper.getAsBoolean((ENode) evaluate); |
| } else if (evaluate instanceof Boolean) { |
| result = ((Boolean) evaluate).booleanValue(); |
| } else if (evaluate instanceof String) { |
| result = Boolean.parseBoolean((String) evaluate); |
| } else if (evaluate instanceof IAdaptable) { |
| final Boolean adaptedBoolean = (Boolean) ((IAdaptable) evaluate).getAdapter(Boolean.class); |
| if (adaptedBoolean != null) |
| result = adaptedBoolean.booleanValue(); |
| } else if (evaluate != null) { |
| // in acceleo, if (something) returns true |
| result = true; |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateEObject(EObject, |
| * String) |
| */ |
| @Deprecated |
| public EObject getAsEObject(final Object result) { |
| return internalGetAsEObject(result); |
| } |
| |
| private EObject internalGetAsEObject(final Object result) { |
| EObject eObject = null; |
| if (result instanceof ENode) { |
| eObject = ENodeHelper.getAsEObject((ENode) result); |
| } else if (result instanceof EObject) { |
| eObject = (EObject) result; |
| } else if (result instanceof IAdaptable) { |
| eObject = (EObject) ((IAdaptable) result).getAdapter(EObject.class); |
| } else if (result instanceof ENodeList) { |
| final ENodeList eNodeList = (ENodeList) result; |
| if (eNodeList.size() > 0) { |
| eObject = internalGetAsEObject(eNodeList.get(0)); |
| } |
| } else if (result instanceof Collection) { |
| final Collection<?> collection = (Collection<?>) result; |
| if (!collection.isEmpty()) { |
| final Object first = collection.iterator().next(); |
| eObject = internalGetAsEObject(first); |
| } |
| } |
| return eObject; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateInteger(EObject, |
| * String) |
| */ |
| @Deprecated |
| public Integer getAsInteger(final Object result) { |
| return internalGetAsInteger(result); |
| } |
| |
| private Integer internalGetAsInteger(final Object result) { |
| Integer integer = null; |
| if (result instanceof ENode) { |
| integer = ENodeHelper.getAsInteger((ENode) result); |
| } else if (result instanceof Integer) { |
| integer = (Integer) result; |
| } else if (result instanceof IAdaptable) { |
| integer = (Integer) ((IAdaptable) result).getAdapter(Integer.class); |
| } else if (result instanceof String) { |
| try { |
| final int res = Integer.parseInt((String) result); |
| integer = Integer.valueOf(res); |
| } catch (final NumberFormatException e) { |
| // silent |
| } |
| } |
| return integer; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateBoolean(EObject, |
| * String) |
| */ |
| @Deprecated |
| public Collection<EObject> getAsListOfEObjects(final Object object) { |
| return internalGetAsListOfEObjects(object); |
| } |
| |
| private Collection<EObject> internalGetAsListOfEObjects(final Object object) { |
| Collection<EObject> result = new LinkedList<EObject>(); |
| if (object instanceof Collection) { |
| final Collection<?> tmp = (Collection<?>) object; |
| for (final Object obj : tmp) { |
| if (obj instanceof EObject) { |
| result.add((EObject) obj); |
| } |
| } |
| } else if (object instanceof ENode) { |
| result = ENodeHelper.getAsListOfEObjects((ENode) object); |
| } else if (object instanceof EObject) { |
| result.add((EObject) object); |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateString(EObject, |
| * String) |
| */ |
| @Deprecated |
| public String getAsString(final Object result) { |
| return internalGetAsString(result); |
| } |
| |
| private String internalGetAsString(final Object result) { |
| if (result instanceof ENode) { |
| return ENodeHelper.getAsString((ENode) result); |
| } |
| return result != null ? result.toString() : null; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#getValue(java.lang.Object, |
| * java.lang.String) |
| */ |
| public Object getValue(final Object object, final String s) { |
| Object result = object; |
| if (object instanceof ENode) { |
| result = ENodeHelper.getValue((ENode) result, s); |
| } |
| return result; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#provides(java.lang.String) |
| */ |
| public boolean provides(final String expression) { |
| return expression != null && expression.indexOf(PREFIX_KEYWORD) >= 0; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateBoolean(org.eclipse.emf.ecore.EObject, |
| * java.lang.String) |
| */ |
| public boolean evaluateBoolean(final EObject context, final String expression) throws EvaluationException { |
| final Object evaluation = evaluate(context, expression); |
| return internalGetAsBoolean(evaluation); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateCollection(org.eclipse.emf.ecore.EObject, |
| * java.lang.String) |
| */ |
| public Collection<EObject> evaluateCollection(final EObject context, final String expression) throws EvaluationException { |
| final Object evaluation = evaluate(context, expression); |
| return internalGetAsListOfEObjects(evaluation); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateEObject(org.eclipse.emf.ecore.EObject, |
| * java.lang.String) |
| */ |
| public EObject evaluateEObject(final EObject context, final String expression) throws EvaluationException { |
| final Object evaluation = evaluate(context, expression); |
| return internalGetAsEObject(evaluation); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateInteger(org.eclipse.emf.ecore.EObject, |
| * java.lang.String) |
| */ |
| public Integer evaluateInteger(final EObject context, final String expression) throws EvaluationException { |
| final Object evaluation = evaluate(context, expression); |
| return internalGetAsInteger(evaluation); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#evaluateString(org.eclipse.emf.ecore.EObject, |
| * java.lang.String) |
| */ |
| public String evaluateString(final EObject context, final String expression) throws EvaluationException { |
| final Object evaluation = evaluate(context, expression); |
| return internalGetAsString(evaluation); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#getVariable(java.lang.String) |
| */ |
| public Object getVariable(final String name) { |
| final ENode node = getVariableValue(name); |
| return getValue(node, ""); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#setProperty(java.lang.Object, |
| * java.lang.Object) |
| */ |
| public void setProperty(final Object key, final Object value) { |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#dispose() |
| */ |
| public void dispose() { |
| for (final Map.Entry<SpecificScript, Map<String, Template>> child : templates.entrySet()) |
| child.getValue().clear(); |
| templates.clear(); |
| this.variableTables.clear(); |
| this.variablesListeners.clear(); |
| this.imports.clear(); |
| this.deactivateCache(); |
| uninstallWorkspaceListener(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#setModelAccessor(org.eclipse.sirius.ecore.extender.business.api.accessor.ModelAccessor) |
| */ |
| public void setModelAccessor(final ModelAccessor modelAccessor) { |
| // ignore. |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreterProvider#createInterpreter() |
| */ |
| public abstract IInterpreter createInterpreter(); |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.contentassist.IProposalProvider#getProposals(org.eclipse.sirius.common.tools.api.interpreter.IInterpreter, |
| * org.eclipse.sirius.common.tools.api.contentassist.ContentContext) |
| */ |
| public List<ContentProposal> getProposals(IInterpreter interpreter, ContentContext context) { |
| return getCompletionEntry().computeProposals(context); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#getPrefix() |
| */ |
| public String getPrefix() { |
| return PREFIX_KEYWORD; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#getNewEmtpyExpression() |
| */ |
| public ContentProposal getNewEmtpyExpression() { |
| return new ContentProposal(PREFIX_KEYWORD + SUFFIX_KEYWORD, PREFIX_KEYWORD + SUFFIX_KEYWORD, "New legacy query language expression.", 2); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#getVariablePrefix() |
| */ |
| public String getVariablePrefix() { |
| return VARIABLE_KEYWORD; |
| } |
| |
| /** |
| * |
| * {@inheritDoc} |
| */ |
| public void setCrossReferencer(final ECrossReferenceAdapter crossReferencer) { |
| // no handling of cross referencer with specific script. (yet ;) ) |
| } |
| |
| /** |
| * Returns the result of the evaluation from the cache. |
| * |
| * @param context |
| * the context of the evaluation. |
| * @param evaluation |
| * the evaluation. |
| * @param args |
| * the arguments of the evaluation. |
| * @return the result of the evaluation from the cache. |
| */ |
| protected ENode getFromCache(final ENode context, final String evaluation, final ENode[] args) { |
| if (cache != null) { |
| return cache.get(new CacheKey(context, evaluation, args)); |
| } |
| return null; |
| } |
| |
| /** |
| * Caches an evaluation. |
| * |
| * @param context |
| * the context. |
| * @param evaluation |
| * the evaluation. |
| * @param args |
| * the arguments of the evaluation. |
| * @param result |
| * the result of the evaluation. |
| */ |
| protected void cache(final ENode context, final String evaluation, final ENode[] args, final ENode result) { |
| if (cache != null) |
| cache.put(new CacheKey(context, evaluation, args), result); |
| } |
| |
| /** |
| * Activates the cache. |
| */ |
| public void activateCache() { |
| if (this.cache == null) |
| this.cache = new HashMap<CacheKey, ENode>(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#activateMetamodels(java.util.Collection) |
| */ |
| public void activateMetamodels(Collection<MetamodelDescriptor> metamodels) { |
| // Nothing to do |
| } |
| |
| /** |
| * Deactivates the cache. |
| */ |
| public void deactivateCache() { |
| if (this.cache != null) { |
| this.cache.clear(); |
| this.cache = null; |
| } |
| } |
| |
| /** |
| * Inner Class CacheKey |
| */ |
| private static class CacheKey { |
| |
| private ENode context; |
| |
| private String evaluation; |
| |
| private ENode[] args; |
| |
| public CacheKey(final ENode context, final String evaluation, final ENode[] args) { |
| this.context = context; |
| this.evaluation = evaluation; |
| this.args = args; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see java.lang.Object#hashCode() |
| */ |
| @Override |
| public int hashCode() { |
| final int prime = 31; |
| int result = 1; |
| result = prime * result + (evaluation == null ? 0 : evaluation.hashCode()); |
| result = prime * result + (context == null ? 0 : hashCode(context)); |
| for (ENode node : args) { |
| result = prime * result + (node == null ? 0 : hashCode(node)); |
| } |
| return result; |
| } |
| |
| private int hashCode(final ENode node) { |
| int value = 0; |
| if (node.getValue() != null) { |
| if (!node.isList()) { |
| return node.getValue().hashCode(); |
| } else { |
| try { |
| final ENodeIterator iterNodes = node.getList().iterator(); |
| while (iterNodes.hasNext()) { |
| value += hashCode(iterNodes.next()); |
| } |
| } catch (final ENodeCastException e) { |
| AcceleoInterpreterPlugin.getDefault().error(e.getMessage(), e); |
| } |
| } |
| } |
| return value; |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see java.lang.Object#equals(java.lang.Object) |
| */ |
| @Override |
| public boolean equals(final Object obj) { |
| boolean result = false; |
| if (obj instanceof CacheKey) { |
| result = equals((CacheKey) obj); |
| } |
| return result; |
| } |
| |
| private boolean equals(final CacheKey cacheKey) { |
| final boolean node = (this.context == null && cacheKey.context == null) || (this.context != null && this.context.equals((Object) cacheKey.context)); |
| final boolean eval = node && ((this.evaluation == null && cacheKey.evaluation == null) || (this.evaluation != null && this.evaluation.equals(cacheKey.evaluation))); |
| boolean result = eval && this.args.length == cacheKey.args.length; |
| for (int i = 0; i < args.length && result; i++) { |
| result = this.args[i].equals((Object) cacheKey.args[i]); |
| } |
| return result; |
| } |
| |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.contentassist.IProposalProvider#getProposals(org.eclipse.sirius.common.tools.api.interpreter.IInterpreter, |
| * org.eclipse.sirius.common.tools.api.contentassist.ContentInstanceContext) |
| */ |
| public List<ContentProposal> getProposals(IInterpreter interpreter, ContentInstanceContext context) { |
| final String textSoFar = context.getTextSoFar(); |
| String evaluationString = textSoFar.substring(0, context.getCursorPosition()); |
| |
| if (evaluationString.toLowerCase().startsWith(PREFIX_KEYWORD)) { |
| // Ask AcceleoCompletionEntry for proposals and process them |
| List<ContentProposal> resultList = getCompletionEntry().computeProposals(context); |
| if (resultList.size() > 0) { |
| return resultList; |
| } |
| } |
| |
| return Collections.emptyList(); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#getImports() |
| */ |
| public Collection<String> getImports() { |
| return Collections.<String> unmodifiableCollection(this.imports); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see org.eclipse.sirius.common.tools.api.interpreter.IInterpreter#removeImport(String) |
| */ |
| public void removeImport(String dependency) { |
| if (this.imports.contains(dependency)) { |
| this.imports.remove(dependency); |
| mmToScript.clear(); |
| } |
| templates.clear(); |
| } |
| |
| protected AcceleoCompletionEntry getCompletionEntry() { |
| return new AcceleoCompletionEntry(); |
| } |
| |
| /** |
| * install workspace listener |
| */ |
| private void installWorkspaceListener() { |
| if (templateListener == null) { |
| templateListener = new AcceleoTemplateWorkspaceListener(this); |
| final IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| workspace.addResourceChangeListener(templateListener); |
| } |
| } |
| |
| /** |
| * uninstall workspace listener. |
| */ |
| private void uninstallWorkspaceListener() { |
| if (templateListener != null) { |
| final IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| workspace.removeResourceChangeListener(templateListener); |
| templateListener = null; |
| } |
| } |
| |
| /** |
| * Clear templates stored. |
| */ |
| protected void reconsiderTemplateFiles() { |
| for (final Map.Entry<SpecificScript, Map<String, Template>> child : templates.entrySet()) |
| child.getValue().clear(); |
| |
| mmToScript.clear(); |
| templates.clear(); |
| } |
| |
| } |
