plugins/org.eclipse.gmf.xpand.ant/src/org/eclipse/gmf/internal/xpand/ant/XpandFacade.java - gerrit/gmf-tooling/org.eclipse.gmf-tooling - Git at Google

 /*
  * 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;
 	}

 }
	/*
	* 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;
	}

	}