examples/org.eclipse.ocl.examples.codegen/src/org/eclipse/ocl/examples/codegen/genmodel/OCLGenModelGeneratorAdapter.java - ocl/org.eclipse.ocl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013, 2018 Willink Transformations and others.
  * All rights reserved.   This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v20.html
  *
  * Contributors:
  *   E.D.Willink - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.ocl.examples.codegen.genmodel;

 import java.io.File;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.emf.codegen.ecore.generator.Generator;
 import org.eclipse.emf.codegen.ecore.generator.GeneratorAdapterFactory;
 import org.eclipse.emf.codegen.ecore.genmodel.generator.GenModelGeneratorAdapter;
 import org.eclipse.emf.codegen.jet.JETEmitter;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.plugin.EcorePlugin;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.ocl.examples.codegen.dynamic.JavaFileUtil;
 import org.eclipse.ocl.pivot.utilities.ClassUtil;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.wiring.BundleWiring;

 //
 //	Overridden to allow static templates to be invoked.
 //
 @Deprecated		/* @deprecated temporary workaround for Bug 543870 */
 public class OCLGenModelGeneratorAdapter extends GenModelGeneratorAdapter
 {
 	/**
 	 * TemplateClassLoader overrides URLClassLoader to provide the option to return null
 	 * from loadTemplateClass if the explicitly requested class is not found. Other, referenced
 	 * classes, requested via loadClass fall-back on the classLoader if the urls access fails.
 	 *
 	 * This class and OCLGenModelGeneratorAdapter can be deleted if Bug 543870 fix is available.
 	 */
 	protected static class TemplateClassLoader extends URLClassLoader
 	{
 		/**
 		 * The ClassLoader to be used to load not-nested classes referenced from a template class.
 		 */
 		private final @NonNull ClassLoader classLoader;

 		/**
 		 * The root (qualified, but not-nested) template class names handled by this TemplateClassLoader.
 		 */
 		private final @NonNull Set<@NonNull String> templateClassNames = new HashSet<>();

 		public TemplateClassLoader(@NonNull URL url, @NonNull ClassLoader classLoader) {
 			super(new URL[]{url}, null);		// Suppress default fall-back to parent.
 			assert url != null;
 			assert classLoader != null;
 			this.classLoader =  classLoader;
 		}

 		/**
 		 * Re-implement to load any nested class of any of the templateClassNames direct from its class file.
 		 * Other classes are loaded by the normal classLoader.
 		 */
 		@Override
 		protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
 			int index = className.indexOf("$");
 			String rootClassName = index >= 0 ? className.substring(0, index) : className;
 			if (templateClassNames.contains(rootClassName)) {
 				return super.loadClass(className, resolve);
 			}
 			else {
 				return classLoader.loadClass(className);
 			}
 		}

 		/**
 		 * Load and return the templateClassName using the templateClassPath configuring the template
 		 * class loader to also load the templateClassName's nested classes. Returns null if no
 		 * template class found. This allows a variety of explicit template class paths to be tried
 		 * before a fall back to the normal class loader.
 		 */
 		public Class<?> loadTemplateClass(@NonNull String templateClassName) throws ClassNotFoundException {
 			assert templateClassName != null;
 			Class<?> templateClass = super.loadClass(templateClassName, true);
 			if (templateClass != null) {
 				templateClassNames.add(templateClassName);
 			}
 			return templateClass;
 		}
 	}

 	/**
 	 * Cached sorted standalone classpath entries.
 	 */
 	private @NonNull String[] sortedClasspath = null;

 	/**
 	 * Map from templateClassPath to the TemplatePathClassLoader that loads direct from the class file. These classes
 	 * remain loaded for the lifetime of this AbstractGeneratorAdapter. i.e. Re-open the GenModel
 	 * editor to respond to changed classes.
 	 */
 	private Map<@NonNull File, @NonNull TemplateClassLoader> templatePath2classLoader = null;

 	public OCLGenModelGeneratorAdapter(@NonNull GeneratorAdapterFactory generatorAdapterFactory) {
 		super(generatorAdapterFactory);
 	}

 	/**
 	 * Return the java.class.path entry that resolves absoluteTemplateName references.
 	 * This is only useful when running standalone. When using OSGI, the appropriate bundle-specific
 	 * class loader should be used instead.
 	 */
 	protected @Nullable String getStandaloneTemplateClassPath(@NonNull String workspaceName) {
 		URI absoluteTemplateURI = EcorePlugin.resolvePlatformResourcePath(workspaceName);
 		if (absoluteTemplateURI == null) {
 			return null;
 		}
 		if (absoluteTemplateURI.isArchive()) {
 			absoluteTemplateURI = URI.createURI(absoluteTemplateURI.authority() + absoluteTemplateURI.path());
 		}
 		String absoluteTemplateName = absoluteTemplateURI.isFile() ? absoluteTemplateURI.toFileString() : absoluteTemplateURI.toString();
 		if (absoluteTemplateName == null) {			// Never happens
 			return null;
 		}
 		if (sortedClasspath == null) {
 			sortedClasspath = System.getProperty("java.class.path").split(System.getProperty("path.separator"));
 			Arrays.sort(sortedClasspath);
 		}
 		int matchIndex  = Arrays.binarySearch(sortedClasspath, absoluteTemplateName);
 		if (matchIndex >= 0) {          // Never happens - unless the templateDirectory is actually the bin folder
 			return sortedClasspath[matchIndex];
 		}
 		int insertionPoint = -(matchIndex + 1);  //  classpath[insertionPoint-1] < absoluteTemplateName < classpath[insertionPoint]
 		if (insertionPoint <= 0) {
 			return sortedClasspath[0];
 		}
 		if (insertionPoint >= sortedClasspath.length) {
 			return sortedClasspath[sortedClasspath.length-1];
 		}
 		String prevClassElement = sortedClasspath[insertionPoint-1];
 		String nextClassElement = sortedClasspath[insertionPoint];
 		int prevLength = prevClassElement.length();
 		int nextLength = nextClassElement.length();
 		int absoluteTemplateNameLength = absoluteTemplateName.length();
 		for (int i = 0; i < absoluteTemplateNameLength; i++) {
 			char c = absoluteTemplateName.charAt(i);
 			if (i >= prevLength) {          // prevClassElement is prefix
 				return prevClassElement;
 			}
 			if (i >= nextLength) {          // nextClassElement is prefix
 				return nextClassElement;
 			}
 			char prevC = prevClassElement.charAt(i);
 			if (prevC != c) {
 				return nextClassElement;
 			}
 			char nextC = nextClassElement.charAt(i);
 			if (nextC != c) {
 				return prevClassElement;
 			}
 		}
 		return prevClassElement;          // Never happens, unless there are duplicates in which case nextClassElement is the same.
 	}

 	/**
 	 * If {@link Generator.Options#dynamicTemplates dynamic templates} are not being used,
 	 * attempts to set the emitter to use an existing, precompiled template class
 	 * that has the given method name and argument types.
 	 * @since 2.5
 	 */
 	@Override
 	protected void setStaticTemplateClass(JETEmitter jetEmitter, String className, String methodName, Class<?>[] arguments)
 	{
 		assert className != null;
 		if (!getGenerator().getOptions().dynamicTemplates)
 		{
 			Class<?> templateClass = null;
 			List<String> userTemplatePath = getUserTemplatePath();	// Omit the built-in emf.codegen.ecore to avoid caching; go direct to the fallback
 			if (!userTemplatePath.isEmpty()) {
 				templateClass = getStaticUserTemplateClass(userTemplatePath, className);
 			}
 			try {
 				if (templateClass == null) {							// Fall-back load as an ordinary class
 					templateClass = getClass().getClassLoader().loadClass(className);
 				}
 				Method emitterMethod = templateClass.getDeclaredMethod(methodName, arguments);
 				jetEmitter.setMethod(emitterMethod);
 			}
 			catch (Exception exception)
 			{
 				// It's okay for there not be a precompiled template, so fail quietly.
 			}
 		}
 	}

 	public @Nullable Class<?> getStaticUserTemplateClass(@NonNull List<String> userTemplatePath, @NonNull String className) {
 		if (templatePath2classLoader == null) {
 			templatePath2classLoader = new HashMap<>();
 		}
 		//
 		//  Try to load the className direct from the classPath corresponding to each templatePath element,
 		//
 		for (String templateElement : userTemplatePath) {
 			try {
 				ClassLoader classLoader = getClass().getClassLoader();
 				File templateClassPathFile = null;					// e.g. E:\...
 				URI uri = URI.createURI(templateElement);
 				if (uri.isPlatform()) {
 					URI deresolveURI = uri.isPlatformResource() ? URI.createPlatformResourceURI("/", false) : URI.createPlatformPluginURI("/", false);
 					URI workspaceURI = uri.deresolve(deresolveURI);
 					String workspaceName = "/" + workspaceURI.toString();
 					IWorkspaceRoot root = EcorePlugin.getWorkspaceRoot();
 					if (root != null) {
 						String projectName = workspaceURI.segment(0);
 						Bundle bundle = Platform.getBundle(projectName);
 						BundleWiring bundleWiring = ClassUtil.nonNullState(bundle.adapt(BundleWiring.class));
 						classLoader = bundleWiring.getClassLoader();
 						templateClassPathFile = JavaFileUtil.getOSGIClassPath(bundle);
 					}
 					else {
 						String templateClassPath2 = getStandaloneTemplateClassPath(workspaceName);
 						if (templateClassPath2 != null) {
 							templateClassPathFile = new File(templateClassPath2);
 						}
 					}
 				}
 				else if (uri.isFile()) {
 					templateClassPathFile = new File(uri.toString());
 				}
 				else {
 					templateClassPathFile = new File(uri.toFileString());
 				}
 				if (templateClassPathFile != null) {
 					TemplateClassLoader templatePathClassLoader = templatePath2classLoader.get(templateClassPathFile);
 					if (templatePathClassLoader == null) {
 						assert classLoader != null;
 						String templateClassPathString = URI.createFileURI(templateClassPathFile.toString()).toString();		// e.g. file:/E:/...
 						URL templateClassPathURL = new URL(templateClassPathFile.isFile() ? templateClassPathString : templateClassPathString + "/");	// e.g. file:/E:/... ...jar or .../bin/
 						templatePathClassLoader = new TemplateClassLoader(templateClassPathURL, classLoader);
 						templatePath2classLoader.put(templateClassPathFile, templatePathClassLoader);
 					}
 					return templatePathClassLoader.loadTemplateClass(className);
 				}
 			}
 			catch (Exception e) {
 				getClass();
 				// If some template path attempt fails just move on to the next one.}
 			}
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2013, 2018 Willink Transformations and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v20.html
	*
	* Contributors:
	* E.D.Willink - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.ocl.examples.codegen.genmodel;

	import java.io.File;
	import java.lang.reflect.Method;
	import java.net.URL;
	import java.net.URLClassLoader;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.emf.codegen.ecore.generator.Generator;
	import org.eclipse.emf.codegen.ecore.generator.GeneratorAdapterFactory;
	import org.eclipse.emf.codegen.ecore.genmodel.generator.GenModelGeneratorAdapter;
	import org.eclipse.emf.codegen.jet.JETEmitter;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.plugin.EcorePlugin;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.ocl.examples.codegen.dynamic.JavaFileUtil;
	import org.eclipse.ocl.pivot.utilities.ClassUtil;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.wiring.BundleWiring;

	//
	// Overridden to allow static templates to be invoked.
	//
	@Deprecated /* @deprecated temporary workaround for Bug 543870 */
	public class OCLGenModelGeneratorAdapter extends GenModelGeneratorAdapter
	{
	/**
	* TemplateClassLoader overrides URLClassLoader to provide the option to return null
	* from loadTemplateClass if the explicitly requested class is not found. Other, referenced
	* classes, requested via loadClass fall-back on the classLoader if the urls access fails.
	*
	* This class and OCLGenModelGeneratorAdapter can be deleted if Bug 543870 fix is available.
	*/
	protected static class TemplateClassLoader extends URLClassLoader
	{
	/**
	* The ClassLoader to be used to load not-nested classes referenced from a template class.
	*/
	private final @NonNull ClassLoader classLoader;

	/**
	* The root (qualified, but not-nested) template class names handled by this TemplateClassLoader.
	*/
	private final @NonNull Set<@NonNull String> templateClassNames = new HashSet<>();

	public TemplateClassLoader(@NonNull URL url, @NonNull ClassLoader classLoader) {
	super(new URL[]{url}, null); // Suppress default fall-back to parent.
	assert url != null;
	assert classLoader != null;
	this.classLoader = classLoader;
	}

	/**
	* Re-implement to load any nested class of any of the templateClassNames direct from its class file.
	* Other classes are loaded by the normal classLoader.
	*/
	@Override
	protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
	int index = className.indexOf("$");
	String rootClassName = index >= 0 ? className.substring(0, index) : className;
	if (templateClassNames.contains(rootClassName)) {
	return super.loadClass(className, resolve);
	}
	else {
	return classLoader.loadClass(className);
	}
	}

	/**
	* Load and return the templateClassName using the templateClassPath configuring the template
	* class loader to also load the templateClassName's nested classes. Returns null if no
	* template class found. This allows a variety of explicit template class paths to be tried
	* before a fall back to the normal class loader.
	*/
	public Class<?> loadTemplateClass(@NonNull String templateClassName) throws ClassNotFoundException {
	assert templateClassName != null;
	Class<?> templateClass = super.loadClass(templateClassName, true);
	if (templateClass != null) {
	templateClassNames.add(templateClassName);
	}
	return templateClass;
	}
	}

	/**
	* Cached sorted standalone classpath entries.
	*/
	private @NonNull String[] sortedClasspath = null;

	/**
	* Map from templateClassPath to the TemplatePathClassLoader that loads direct from the class file. These classes
	* remain loaded for the lifetime of this AbstractGeneratorAdapter. i.e. Re-open the GenModel
	* editor to respond to changed classes.
	*/
	private Map<@NonNull File, @NonNull TemplateClassLoader> templatePath2classLoader = null;

	public OCLGenModelGeneratorAdapter(@NonNull GeneratorAdapterFactory generatorAdapterFactory) {
	super(generatorAdapterFactory);
	}

	/**
	* Return the java.class.path entry that resolves absoluteTemplateName references.
	* This is only useful when running standalone. When using OSGI, the appropriate bundle-specific
	* class loader should be used instead.
	*/
	protected @Nullable String getStandaloneTemplateClassPath(@NonNull String workspaceName) {
	URI absoluteTemplateURI = EcorePlugin.resolvePlatformResourcePath(workspaceName);
	if (absoluteTemplateURI == null) {
	return null;
	}
	if (absoluteTemplateURI.isArchive()) {
	absoluteTemplateURI = URI.createURI(absoluteTemplateURI.authority() + absoluteTemplateURI.path());
	}
	String absoluteTemplateName = absoluteTemplateURI.isFile() ? absoluteTemplateURI.toFileString() : absoluteTemplateURI.toString();
	if (absoluteTemplateName == null) { // Never happens
	return null;
	}
	if (sortedClasspath == null) {
	sortedClasspath = System.getProperty("java.class.path").split(System.getProperty("path.separator"));
	Arrays.sort(sortedClasspath);
	}
	int matchIndex = Arrays.binarySearch(sortedClasspath, absoluteTemplateName);
	if (matchIndex >= 0) { // Never happens - unless the templateDirectory is actually the bin folder
	return sortedClasspath[matchIndex];
	}
	int insertionPoint = -(matchIndex + 1); // classpath[insertionPoint-1] < absoluteTemplateName < classpath[insertionPoint]
	if (insertionPoint <= 0) {
	return sortedClasspath[0];
	}
	if (insertionPoint >= sortedClasspath.length) {
	return sortedClasspath[sortedClasspath.length-1];
	}
	String prevClassElement = sortedClasspath[insertionPoint-1];
	String nextClassElement = sortedClasspath[insertionPoint];
	int prevLength = prevClassElement.length();
	int nextLength = nextClassElement.length();
	int absoluteTemplateNameLength = absoluteTemplateName.length();
	for (int i = 0; i < absoluteTemplateNameLength; i++) {
	char c = absoluteTemplateName.charAt(i);
	if (i >= prevLength) { // prevClassElement is prefix
	return prevClassElement;
	}
	if (i >= nextLength) { // nextClassElement is prefix
	return nextClassElement;
	}
	char prevC = prevClassElement.charAt(i);
	if (prevC != c) {
	return nextClassElement;
	}
	char nextC = nextClassElement.charAt(i);
	if (nextC != c) {
	return prevClassElement;
	}
	}
	return prevClassElement; // Never happens, unless there are duplicates in which case nextClassElement is the same.
	}

	/**
	* If {@link Generator.Options#dynamicTemplates dynamic templates} are not being used,
	* attempts to set the emitter to use an existing, precompiled template class
	* that has the given method name and argument types.
	* @since 2.5
	*/
	@Override
	protected void setStaticTemplateClass(JETEmitter jetEmitter, String className, String methodName, Class<?>[] arguments)
	{
	assert className != null;
	if (!getGenerator().getOptions().dynamicTemplates)
	{
	Class<?> templateClass = null;
	List<String> userTemplatePath = getUserTemplatePath(); // Omit the built-in emf.codegen.ecore to avoid caching; go direct to the fallback
	if (!userTemplatePath.isEmpty()) {
	templateClass = getStaticUserTemplateClass(userTemplatePath, className);
	}
	try {
	if (templateClass == null) { // Fall-back load as an ordinary class
	templateClass = getClass().getClassLoader().loadClass(className);
	}
	Method emitterMethod = templateClass.getDeclaredMethod(methodName, arguments);
	jetEmitter.setMethod(emitterMethod);
	}
	catch (Exception exception)
	{
	// It's okay for there not be a precompiled template, so fail quietly.
	}
	}
	}

	public @Nullable Class<?> getStaticUserTemplateClass(@NonNull List<String> userTemplatePath, @NonNull String className) {
	if (templatePath2classLoader == null) {
	templatePath2classLoader = new HashMap<>();
	}
	//
	// Try to load the className direct from the classPath corresponding to each templatePath element,
	//
	for (String templateElement : userTemplatePath) {
	try {
	ClassLoader classLoader = getClass().getClassLoader();
	File templateClassPathFile = null; // e.g. E:\...
	URI uri = URI.createURI(templateElement);
	if (uri.isPlatform()) {
	URI deresolveURI = uri.isPlatformResource() ? URI.createPlatformResourceURI("/", false) : URI.createPlatformPluginURI("/", false);
	URI workspaceURI = uri.deresolve(deresolveURI);
	String workspaceName = "/" + workspaceURI.toString();
	IWorkspaceRoot root = EcorePlugin.getWorkspaceRoot();
	if (root != null) {
	String projectName = workspaceURI.segment(0);
	Bundle bundle = Platform.getBundle(projectName);
	BundleWiring bundleWiring = ClassUtil.nonNullState(bundle.adapt(BundleWiring.class));
	classLoader = bundleWiring.getClassLoader();
	templateClassPathFile = JavaFileUtil.getOSGIClassPath(bundle);
	}
	else {
	String templateClassPath2 = getStandaloneTemplateClassPath(workspaceName);
	if (templateClassPath2 != null) {
	templateClassPathFile = new File(templateClassPath2);
	}
	}
	}
	else if (uri.isFile()) {
	templateClassPathFile = new File(uri.toString());
	}
	else {
	templateClassPathFile = new File(uri.toFileString());
	}
	if (templateClassPathFile != null) {
	TemplateClassLoader templatePathClassLoader = templatePath2classLoader.get(templateClassPathFile);
	if (templatePathClassLoader == null) {
	assert classLoader != null;
	String templateClassPathString = URI.createFileURI(templateClassPathFile.toString()).toString(); // e.g. file:/E:/...
	URL templateClassPathURL = new URL(templateClassPathFile.isFile() ? templateClassPathString : templateClassPathString + "/"); // e.g. file:/E:/... ...jar or .../bin/
	templatePathClassLoader = new TemplateClassLoader(templateClassPathURL, classLoader);
	templatePath2classLoader.put(templateClassPathFile, templatePathClassLoader);
	}
	return templatePathClassLoader.loadTemplateClass(className);
	}
	}
	catch (Exception e) {
	getClass();
	// If some template path attempt fails just move on to the next one.}
	}
	}
	return null;
	}
	}