/*
* Copyright (c) 2007, 2009 Borland Software Corporation
*
* 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
*/
package org.eclipse.gmf.internal.xpand.ant;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.emf.ecore.EPackage.Registry;
import org.eclipse.emf.ecore.impl.EPackageRegistryImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.gmf.internal.xpand.Activator;
import org.eclipse.gmf.internal.xpand.BufferOutput;
import org.eclipse.gmf.internal.xpand.BuiltinMetaModel;
import org.eclipse.gmf.internal.xpand.ResourceManager;
import org.eclipse.gmf.internal.xpand.StreamsHolder;
import org.eclipse.gmf.internal.xpand.model.AmbiguousDefinitionException;
import org.eclipse.gmf.internal.xpand.model.EvaluationException;
import org.eclipse.gmf.internal.xpand.model.ExecutionContext;
import org.eclipse.gmf.internal.xpand.model.ExecutionContextImpl;
import org.eclipse.gmf.internal.xpand.model.Scope;
import org.eclipse.gmf.internal.xpand.model.Variable;
import org.eclipse.gmf.internal.xpand.model.XpandDefinition;
import org.eclipse.gmf.internal.xpand.util.BundleResourceManager;
import org.eclipse.gmf.internal.xpand.xtend.ast.QvtResource;
import org.eclipse.m2m.internal.qvt.oml.expressions.Module;
import org.eclipse.m2m.internal.qvt.oml.runtime.util.OCLEnvironmentWithQVTAccessFactory;
import org.eclipse.ocl.ParserException;
import org.eclipse.ocl.ecore.EcoreEvaluationEnvironment;
import org.eclipse.ocl.ecore.EcoreFactory;
import org.eclipse.ocl.ecore.OCL;
import org.eclipse.ocl.ecore.OCLExpression;
import org.eclipse.ocl.ecore.OCL.Helper;
import org.eclipse.ocl.ecore.OCL.Query;
import org.osgi.framework.Bundle;
/**
* Redistributable API for Xpand evaluation
* @author artem
*/
public final class XpandFacade {
private static final String IMPLICIT_VAR_NAME = "self"; //$NON-NLS-1$
private static final String IMPLICIT_VAR_NAME_BACKWARD_COMPATIBILITY = "this"; //$NON-NLS-1$
private final LinkedList<Variable> myGlobals = new LinkedList<Variable>();
private final LinkedList<URL> myLocations = new LinkedList<URL>();
private final LinkedList<String> myImportedModels = new LinkedList<String>();
private final LinkedList<String> myExtensionFiles = new LinkedList<String>();
private boolean myEnforceReadOnlyNamedStreamsAfterAccess = false;
private ExecutionContext myXpandCtx;
private BufferOutput myBufferOut;
private HashMap<Object, StreamsHolder> myStreamsHolders;
private final StringBuilder myOut = new StringBuilder();
private Map<String, URI> myMetamodelURI2LocationMap = new HashMap<String, URI>();
private final ResourceSet myResourceSet;
private Map<String, URI> mySchemaLocations;
public XpandFacade(ResourceSet resourceSet) {
myResourceSet = resourceSet;
}
/**
* Sort of copy constructor, create a new facade pre-initialized with values
* of existing one.
* @param chain facade to copy settings (globals, locations, metamodels, extensions, loaders) from, can't be <code>null</code>.
*/
public XpandFacade(XpandFacade chain) {
assert chain != null;
myGlobals.addAll(chain.myGlobals);
myLocations.addAll(chain.myLocations);
myImportedModels.addAll(chain.myImportedModels);
myExtensionFiles.addAll(chain.myExtensionFiles);
//
// not necessary, but doesn't seem to hurt
myXpandCtx = chain.myXpandCtx; // new state is formed with cloning
myResourceSet = chain.myResourceSet;
myMetamodelURI2LocationMap = chain.myMetamodelURI2LocationMap;
mySchemaLocations = chain.mySchemaLocations;
}
/**
* Named streams (those created by <<FILE file slotName>> syntax) may be put into a strict mode that prevents write operations
* after the contents of the stream have been accessed. By default, named streams are not in strict mode.
* @param value
*/
public void setEnforceReadOnlyNamedStreamsAfterAccess(boolean value) {
myEnforceReadOnlyNamedStreamsAfterAccess = value;
}
public void addGlobal(String name, Object value) {
assert name != null;
for (Iterator<Variable> it = myGlobals.listIterator(); it.hasNext();) {
if (it.next().getName().equals(name)) {
it.remove();
}
}
if (name == null || value == null) {
return;
}
myGlobals.addFirst(new Variable(name, null, value));
clearAllContexts();
}
public void addLocation(String url) throws MalformedURLException {
addLocation(new URL(url));
}
public void addLocation(URL url) {
assert url != null;
myLocations.addLast(url);
clearAllContexts();
}
public void registerMetamodel(String nsUri, URI location) {
if (!myMetamodelURI2LocationMap.containsKey(nsUri)) {
myMetamodelURI2LocationMap.put(nsUri, location);
}
}
public void setSchemaLocations(Map<String, URI> schemaLocations) {
mySchemaLocations = schemaLocations;
}
/**
* Registers a class loader to load Java classes accessed from templates and/or expressions.
* @param loader ClassLoader to load classes though
* @deprecated QVT-based dialect of Xpand does not use classload contexts.
*/
@Deprecated
public void addClassLoadContext(ClassLoader loader) {
//do nothing
}
/**
* Register a bundle to load Java classes from (i.e. JAVA functions in Xtend)
* @param bundle - generally obtained from {@link org.eclipse.core.runtime.Platform#getBundle(String)}, should not be null.
* @deprecated QVT-based dialect of Xpand does not use classload contexts.
*/
@Deprecated
public void addClassLoadContext(Bundle bundle) {
//do nothing
}
public void addMetamodel(String metamodel) {
if (myImportedModels.contains(metamodel)) {
return;
}
myImportedModels.add(metamodel);
}
/**
* @param extensionFile double-colon separated qualified name of qvto file
*/
public void addExtensionFile(String extensionFile) {
if (myExtensionFiles.contains(extensionFile)) {
return;
}
myExtensionFiles.add(extensionFile);
}
public <T> T evaluate(String expression, Object target) {
// XXX perhaps, need to check for target == null and do not set 'this' then
return evaluate(expression, Collections.singletonMap("self", target));
}
/**
* @param expression xtend expression to evaluate
* @param context should not be <code>null</code>
* @return
*/
@SuppressWarnings("unchecked")
public <T> T evaluate(String expression, Map<String,?> context) {
assert context != null; // nevertheless, prevent NPE.
ResourceManager rm;
if (myLocations.isEmpty()) {
try {
// use current default path as root
// use canonicalFile to get rid of dot after it get resolved to
// current dir
rm = new BundleResourceManager(new File(".").getCanonicalFile().toURI().toURL());
} catch (IOException ex) {
// should not happen
rm = null;
}
} else {
rm = new BundleResourceManager(myLocations.toArray(new URL[myLocations.size()]));
}
Set<Module> importedModules = getImportedModules(rm);
OCLEnvironmentWithQVTAccessFactory factory = new OCLEnvironmentWithQVTAccessFactory(importedModules, getAllVisibleModels());
OCL ocl = OCL.newInstance(factory);
Object thisValue = null;
if (context != null) {
for (Map.Entry<String, ?> nextEntry : context.entrySet()) {
String varName = nextEntry.getKey();
Object varValue = nextEntry.getValue();
if (IMPLICIT_VAR_NAME.equals(varName) || IMPLICIT_VAR_NAME_BACKWARD_COMPATIBILITY.equals(varName)) {
assert thisValue == null; //prevent simultaneous this and self
thisValue = varValue;
continue;
}
EClassifier varType = BuiltinMetaModel.getType(getXpandContext(), varValue);
org.eclipse.ocl.ecore.Variable oclVar = EcoreFactory.eINSTANCE.createVariable();
oclVar.setName(varName);
oclVar.setType(varType);
ocl.getEnvironment().addElement(varName, oclVar, true);
}
}
Helper oclHelper = ocl.createOCLHelper();
if (thisValue != null) {
oclHelper.setContext(BuiltinMetaModel.getType(getXpandContext(), thisValue));
} else {
oclHelper.setContext(ocl.getEnvironment().getOCLStandardLibrary().getOclVoid());
}
OCLExpression exp;
try {
exp = oclHelper.createQuery(expression);
} catch (ParserException e) {
// e.printStackTrace();
throw new EvaluationException(e);
}
Query query = ocl.createQuery(exp);
EcoreEvaluationEnvironment ee = (EcoreEvaluationEnvironment) query.getEvaluationEnvironment();
if (context != null) {
for (Map.Entry<String, ?> nextEntry : context.entrySet()) {
String varName = nextEntry.getKey();
Object varValue = nextEntry.getValue();
if (!IMPLICIT_VAR_NAME.equals(varName) && !IMPLICIT_VAR_NAME_BACKWARD_COMPATIBILITY.equals(varName)) {
ee.add(varName, varValue);
}
}
}
Object result;
if (thisValue != null) {
result = query.evaluate(thisValue);
} else {
result = query.evaluate();
}
if (result == ocl.getEnvironment().getOCLStandardLibrary().getOclInvalid()) {
return null; //XXX: or throw an exception?
}
return (T) result;
}
private Set<Module> getImportedModules(ResourceManager rm) {
Set<Module> result = new HashSet<Module>();
for (String extensionFile : myExtensionFiles) {
QvtResource qvtResource = rm.loadQvtResource(extensionFile);
result.addAll(qvtResource.getModules());
}
return result;
}
private EPackage.Registry getAllVisibleModels() {
assert myImportedModels != null;
// TODO respect meta-models imported not only with nsURI
EPackage.Registry result = new EPackageRegistryImpl();
for (String namespace : myImportedModels) {
EPackage pkg = Activator.findMetaModel(namespace);
if (pkg != null) {
result.put(namespace, pkg);
}
}
if (result.isEmpty()) {
// hack for tests
result.put(EcorePackage.eNS_URI, EcorePackage.eINSTANCE);
}
return result;
}
public String xpand(String templateName, Object target, Object... arguments) {
if (target == null) {
return null;
}
clearOut();
ExecutionContext ctx = getXpandContext();
try {
new org.eclipse.gmf.internal.xpand.XpandFacade(ctx).evaluate(templateName, target, arguments);
} catch (AmbiguousDefinitionException e) {
throw new EvaluationException(e);
}
return myOut.toString();
}
public Map<Object, String> xpand(String templateName, Collection<?> target, Object... arguments) {
// though it's reasonable to keep original order of input elements,
// is it worth declaring in API?
LinkedHashMap<Object, String> inputToResult = new LinkedHashMap<Object, String>();
boolean invokeForCollection = findDefinition(templateName, target, arguments) != null;
if (invokeForCollection) {
inputToResult.put(target, xpand(templateName, (Object)target, arguments));
return inputToResult;
}
myStreamsHolders = new HashMap<Object, StreamsHolder>();
for (Object nextInput: target) {
if (nextInput == null) {
continue;
}
String result = xpand(templateName, nextInput, arguments);
inputToResult.put(nextInput, result);
myStreamsHolders.put(nextInput, myBufferOut.getNamedStreams());
}
return inputToResult;
}
/**
* Returns names of named streams that were created during the most recent {@link #xpand(String, Object, Object...) operation and have non-empty contents.
* @return
*/
public Collection<String> getNamedStreams() {
assert myStreamsHolders == null; //if invoked for several elements separately, another version of this method should be used.
if (myBufferOut == null) {
return Collections.emptyList();
}
return myBufferOut.getNamedStreams().getSlotNames();
}
/**
* Returns contents of the named stream that was created during the most recent {@link #xpand(String, Object, Object...) operation.
* If the stream with the given name does not exist, the operation will throw an exception.
* @param streamName
* @return
*/
public String getNamedStreamContents(String streamName) {
assert myStreamsHolders == null; //if invoked for several elements separately, another version of this method should be used.
if (myBufferOut == null) {
throw new UnsupportedOperationException("Stream with the given name does not exist", null);
}
return myBufferOut.getNamedStreams().getStreamContents(streamName);
}
/**
* Returns names of non-empty named streams that were created during the most recent {@link #xpand(String, Collection, Object...)} operation for the given input.
* @return
*/
public Collection<String> getNamedStreams(Object input) {
if (myStreamsHolders == null) {
//assume this is the input that was used during the last invocation, but do not enforce this.
return getNamedStreams();
}
StreamsHolder streamsHolder = myStreamsHolders.get(input);
if (streamsHolder == null) {
return Collections.emptyList();
}
return streamsHolder.getSlotNames();
}
/**
* Returns contents of the named stream that was created during the most recent {@link #xpand(String, Collection, Object...) operation.
* If the stream with the given name does not exist, the operation will throw an exception.
* @param streamName
* @return
*/
public String getNamedStreamContents(Object input, String streamName) {
if (myStreamsHolders == null) {
//assume this is the input that was used during the last invocation, but do not enforce this.
return getNamedStreamContents(streamName);
}
StreamsHolder streamsHolder = myStreamsHolders.get(input);
if (streamsHolder == null) {
throw new UnsupportedOperationException("Stream with the given name does not exist", null);
}
return streamsHolder.getStreamContents(streamName);
}
private XpandDefinition findDefinition(String templateName, Object target, Object[] arguments) {
EClassifier targetType = BuiltinMetaModel.getType(getXpandContext(), target);
final EClassifier[] paramTypes = new EClassifier[arguments == null ? 0 : arguments.length];
for (int i = 0; i < paramTypes.length; i++) {
paramTypes[i] = BuiltinMetaModel.getType(getXpandContext(), arguments[i]);
}
try {
return getXpandContext().findDefinition(templateName, targetType, paramTypes);
} catch (AmbiguousDefinitionException e) {
return null;
}
}
private void clearAllContexts() {
myXpandCtx = null;
}
private void clearOut() {
myOut.setLength(200);
myOut.trimToSize();
myOut.setLength(0);
//To clear streams, we have no other option but to reset the xpand context
myXpandCtx = null;
myBufferOut = null;
}
private ExecutionContext getXpandContext() {
if (myXpandCtx == null) {
BundleResourceManager rm = new BundleResourceManager(myLocations.toArray(new URL[myLocations.size()])) {
@Override
protected ResourceSet getMetamodelResourceSet() {
return myResourceSet;
}
};
myBufferOut = new BufferOutput(myOut, myEnforceReadOnlyNamedStreamsAfterAccess);
Scope scope = new Scope(rm, myGlobals, myBufferOut) {
@Override
public Registry createPackageRegistry(String[] metamodelURIs) {
assert metamodelURIs != null;
EPackage.Registry result = new EPackageRegistryImpl();
for (String namespace : metamodelURIs) {
EPackage pkg;
if (myMetamodelURI2LocationMap.containsKey(namespace)) {
pkg = loadMainEPackage(myMetamodelURI2LocationMap.get(namespace));
} else if (EPackage.Registry.INSTANCE.containsKey(namespace)) {
pkg = EPackage.Registry.INSTANCE.getEPackage(namespace);
} else {
URI metamodelURI = mySchemaLocations.get(namespace);
Resource resource = myResourceSet.getResource(metamodelURI, true);
if (resource.getContents().size() > 0 && resource.getContents().get(0) instanceof EPackage) {
pkg = (EPackage) resource.getContents().get(0);
} else {
pkg = null;
}
}
if (pkg != null) {
result.put(namespace, pkg);
}
}
return result;
}
};
myXpandCtx = new ExecutionContextImpl(scope);
}
return myXpandCtx;
}
private EPackage loadMainEPackage(URI uri) {
Resource resource = myResourceSet.getResource(uri, true);
if (resource.getContents().size() > 0 && resource.getContents().get(0) instanceof EPackage) {
return (EPackage) resource.getContents().get(0);
}
return null;
}
}
