| /* |
| * <copyright> |
| * |
| * Copyright (c) 2005-2008 Sven Efftinge 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: |
| * Sven Efftinge - Initial API and implementation |
| * Alexander Shatalin (Borland) |
| * |
| * </copyright> |
| */ |
| package org.eclipse.gmf.internal.xpand.model; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| |
| import org.eclipse.emf.ecore.EClassifier; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.gmf.internal.xpand.BufferOutput; |
| import org.eclipse.gmf.internal.xpand.ResourceManager; |
| import org.eclipse.gmf.internal.xpand.ResourceMarker; |
| import org.eclipse.gmf.internal.xpand.expression.ExecutionContextImpl; |
| import org.eclipse.gmf.internal.xpand.expression.PolymorphicResolver; |
| import org.eclipse.gmf.internal.xpand.expression.SyntaxConstants; |
| import org.eclipse.gmf.internal.xpand.expression.TypeNameUtil; |
| import org.eclipse.gmf.internal.xpand.expression.Variable; |
| import org.eclipse.gmf.internal.xpand.migration.Activator; |
| |
| /** |
| * * |
| * |
| * @author Sven Efftinge * |
| */ |
| public class XpandExecutionContextImpl extends ExecutionContextImpl implements XpandExecutionContext { |
| |
| protected final Output output; |
| |
| protected final ProtectedRegionResolver protectedRegionResolver; |
| |
| private final List<XpandAdvice> registeredAdvices = new ArrayList<XpandAdvice>(); |
| |
| public XpandExecutionContextImpl(ResourceManager resourceManager, Output output, ProtectedRegionResolver prs) { |
| this (resourceManager, output, prs, null); |
| } |
| |
| public XpandExecutionContextImpl(ResourceManager resourceManager, EPackage... fallbackVisibleModels) { |
| super(resourceManager, fallbackVisibleModels); |
| this.output = new BufferOutput(new StringBuilder()); |
| this.protectedRegionResolver = null; |
| } |
| |
| public XpandExecutionContextImpl(ResourceManager resourceManager, Output output, ProtectedRegionResolver prs, Collection<Variable> globalVars) { |
| super(resourceManager, globalVars); |
| this.output = output; |
| this.protectedRegionResolver = prs; |
| } |
| |
| protected XpandExecutionContextImpl (ResourceManager resourceManager, ResourceMarker currentResource, Collection<Variable> vars, |
| Collection<Variable> globalVars, Output output, ProtectedRegionResolver protectedRegionResolver) { |
| super(resourceManager, currentResource, vars, globalVars); |
| this.output = output; |
| this.protectedRegionResolver = protectedRegionResolver; |
| } |
| |
| /*copy constructor*/ |
| protected XpandExecutionContextImpl(XpandExecutionContextImpl original) { |
| super(original); |
| this.output = original.output; |
| this.protectedRegionResolver = original.protectedRegionResolver; |
| } |
| |
| |
| @Override |
| public XpandExecutionContextImpl cloneContext() { |
| final XpandExecutionContextImpl result = new XpandExecutionContextImpl(this); |
| result.registeredAdvices.addAll(registeredAdvices); //todo: [aha] before I refactored, there was an assignment in this place. Is this modification correct? |
| return result; |
| } |
| |
| public XpandDefinition findDefinition(final String name, final EClassifier target, final EClassifier[] paramTypes) { |
| String templateName; |
| boolean localCall = name.indexOf(SyntaxConstants.NS_DELIM) < 0; |
| if (localCall) { |
| templateName = ((XpandResource) currentResource()).getFullyQualifiedName(); //need an enclosing resource in case of composite |
| } else { |
| templateName = TypeNameUtil.withoutLastSegment(name); |
| } |
| XpandResource tpl = findTemplate(templateName); |
| if (tpl == null) { |
| if (localCall) { |
| tpl = (XpandResource) currentResource(); |
| } else { |
| return null; |
| } |
| } |
| final XpandExecutionContext ctx = (XpandExecutionContext) cloneWithResource(tpl); |
| XpandDefinition def = findDefinition(tpl.getDefinitions(), name, target, paramTypes, ctx); |
| if (def == null) { |
| return null; |
| } |
| XpandAdvice[] advicesInResource = tpl.getAdvices(); |
| for (int x = advicesInResource.length - 1; x >= 0; x--) { |
| final XpandAdvice adv = advicesInResource[x]; |
| if (adv.matches(def, this)) { |
| def = new AdvicedDefinition(adv, def); |
| } |
| } |
| for (int x = registeredAdvices.size() - 1; x >= 0; x--) { |
| final XpandAdvice adv = registeredAdvices.get(x); |
| if (adv.matches(def, this)) { |
| def = new AdvicedDefinition(adv, def); |
| } |
| } |
| return def; |
| } |
| |
| public void registerAdvices(final String fullyQualifiedName) { |
| final XpandResource tpl = findTemplate(fullyQualifiedName); |
| if (tpl == null) { |
| throw new RuntimeException("Couldn't find template : " + fullyQualifiedName); |
| } |
| final XpandAdvice[] as = tpl.getAdvices(); |
| for (final XpandAdvice advice : as) { |
| if (registeredAdvices.contains(advice)) { |
| Activator.logWarn("advice " + advice.toString() + " allready registered!"); |
| } else { |
| registeredAdvices.add(advice); |
| } |
| } |
| } |
| |
| public ProtectedRegionResolver getProtectedRegionResolver() { |
| return protectedRegionResolver; |
| } |
| |
| public Output getOutput() { |
| return output; |
| } |
| |
| @Override |
| protected String[] getImportedNamespaces() { |
| if (currentResource() instanceof XpandResource) { |
| return ((XpandResource) currentResource()).getImportedNamespaces(); |
| } |
| return super.getImportedNamespaces(); |
| } |
| |
| @Override |
| protected String[] getImportedExtensions() { |
| if (currentResource() instanceof XpandResource) { |
| return ((XpandResource) currentResource()).getImportedExtensions(); |
| } |
| return super.getImportedExtensions(); |
| } |
| |
| public XpandResource findTemplate(final String templateName) { |
| if (getResourceManager() == null) { |
| return null; |
| } |
| // XXX findTemplate needs kinda file uri, while metamodel import needs nsURI |
| final List<String> possibleNames = getPossibleNames(templateName, getImportedNamespaces()); |
| for (String name : possibleNames) { |
| final XpandResource tpl = getResourceManager().loadXpandResource(name); |
| if (tpl != null) { |
| // installAspectsFor(templateName); |
| return tpl; |
| } |
| } |
| return null; |
| } |
| |
| // private void installAspectsFor(String templateName) { |
| // String aspectsTemplateName = "aspects" + SyntaxConstants.NS_DELIM + templateName; |
| // XpandResource aspects = getResourceManager().loadXpandResource(aspectsTemplateName); |
| // if (aspects != null) { |
| // registeredAdvices.addAll(Arrays.asList(aspects.getAdvices())); |
| // } |
| // } |
| |
| private List<String> getPossibleNames(final String name, final String[] importedNs) { |
| final String typeName = TypeNameUtil.getTypeName(name); |
| final String typesMetamodelName = TypeNameUtil.getMetaModelName(name); |
| final String collectionTypeName = TypeNameUtil.getCollectionTypeName(name); |
| |
| final List<String> result = new ArrayList<String>(); |
| result.add(name); |
| |
| for (final String string : importedNs) { |
| final StringBuffer s = new StringBuffer(); |
| if (collectionTypeName != null) { |
| s.append(collectionTypeName).append("["); |
| } |
| if (typesMetamodelName != null) { |
| s.append(typesMetamodelName).append("!"); |
| } |
| s.append(string).append(SyntaxConstants.NS_DELIM).append(typeName); |
| if (collectionTypeName != null) { |
| s.append("]"); |
| } |
| result.add(s.toString()); |
| } |
| return result; |
| } |
| |
| /** |
| * resolves the correct definition (using parametric polymorphism) |
| * XXX: get rid of the ctx argument and redeclare as non-static? |
| * @param definitions |
| * @param target |
| * @param paramTypes |
| * @return |
| */ |
| private static XpandDefinition findDefinition(final XpandDefinition[] definitions, final String name, final EClassifier target, |
| EClassifier[] paramTypes, final XpandExecutionContext ctx) { |
| if (paramTypes == null) { |
| paramTypes = new EClassifier[0]; |
| } |
| final String unqualifiedName = TypeNameUtil.getLastSegment(name); |
| // XXX Instead of using map as a mere pair storage, do it like Extension does with init(ctx) |
| // to resolve and keep typed arguments |
| HashMap<XpandDefinition, List<EClassifier>> resolvedDefs = new HashMap<XpandDefinition, List<EClassifier>>(); |
| for (final XpandDefinition def : definitions) { |
| if (!def.getName().equals(unqualifiedName)) { |
| continue; |
| } |
| if (def.getParams().length == paramTypes.length) { |
| final LinkedList<EClassifier> defsParamTypes = new LinkedList<EClassifier>(); |
| EClassifier t = null; |
| boolean complete = true; |
| for (int j = 0; (j < paramTypes.length) && complete; j++) { |
| t = ctx.getTypeForName(def.getParams()[j].getType().getValue()); |
| if (t == null) { |
| complete = false; |
| } |
| defsParamTypes.add(t); |
| } |
| t = ctx.getTypeForName(def.getTargetType()); |
| if (t == null) { |
| complete = false; |
| } else { |
| defsParamTypes.addFirst(t); |
| } |
| if (complete) { |
| resolvedDefs.put(def, defsParamTypes); |
| } |
| } |
| } |
| return PolymorphicResolver.filterDefinition(resolvedDefs, target, Arrays.asList(paramTypes)); |
| } |
| } |
