examples/org.eclipse.ocl.examples.autogen/src/org/eclipse/ocl/examples/autogen/xtend/GenerateAutoLookupInfrastructureXtend.xtend - ocl/org.eclipse.ocl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2015 Willink Transformations, University of York 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:
  *     Adolfo Sanchez-Barbudo Herrera (University of York) - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ocl.examples.autogen.xtend

 import java.util.ArrayList
 import java.util.List
 import org.eclipse.emf.codegen.ecore.genmodel.GenClassifier
 import org.eclipse.emf.codegen.ecore.genmodel.GenPackage
 import org.eclipse.emf.ecore.EPackage
 import org.eclipse.emf.mwe.core.issues.Issues
 import org.eclipse.ocl.examples.codegen.generator.AbstractGenModelHelper
 import org.eclipse.ocl.examples.codegen.generator.GenModelHelper
 import org.eclipse.ocl.pivot.Class
 import org.eclipse.ocl.pivot.Operation
 import org.eclipse.ocl.pivot.Type
 import org.eclipse.ocl.pivot.internal.manager.PivotMetamodelManager
 import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal
 import org.eclipse.ocl.pivot.utilities.ClassUtil
 import org.eclipse.ocl.pivot.utilities.EnvironmentFactory
 import org.eclipse.ocl.pivot.CollectionType
 import org.eclipse.ocl.pivot.utilities.OCL
 import org.eclipse.ocl.examples.build.utilities.GenPackageHelper
 import org.eclipse.ocl.examples.autogen.lookup.LookupCodeGenerator
 import org.eclipse.ocl.xtext.completeocl.CompleteOCLStandaloneSetup
 import org.eclipse.ocl.pivot.model.OCLstdlib
 import java.util.Set
 import org.eclipse.ocl.examples.autogen.lookup.LookupCGUtil
 import org.eclipse.ocl.examples.build.xtend.GenerateVisitorsXtend
 import org.eclipse.ocl.examples.build.xtend.MergeWriter

 class GenerateAutoLookupInfrastructureXtend extends GenerateVisitorsXtend
 {

 	protected String lookupFilePath;
 	// FIXME The lookupVisitor will be in the normal visitors folder, but all the artifacts generated by this component
 	// will be in a different one
 	protected String lookupArtifactsJavaPackage;
 	protected String lookupArtifactsOutputFolder;
 	protected String lookupPackageName;
 	protected String superLookupPackageName
 	protected String baseLookupPackageName
 	protected GenModelHelper genModelHelper;

 	override checkConfiguration(Issues issues) {
 		super.checkConfiguration(issues);
 		if (!isDefined(lookupFilePath)) {
 			issues.addError(this, "lookupFilePath must be specified");
 		}
 	}

 	/**
 	 * The path inside the projectName to the Complete OCL file which contains the
 	 * name resolution description (e.g. "model/NameResolution.ocl"). It
 	 * can't be null
 	 */
 	def setLookupFilePath(String lookupFilePath) {
 		this.lookupFilePath = lookupFilePath;
 	}

 	def setLookupPackageName(String lookupPackageName) {
 		this.lookupPackageName = lookupPackageName;
 	}

 	def setSuperLookupPackageName(String superLookupPackageName) {
 		this.superLookupPackageName = superLookupPackageName;
 	}

 	def setBaseLookupPackageName(String baseLookupPackageName) {
 		this.baseLookupPackageName = baseLookupPackageName;
 	}

 	protected override doSetup() {
 		CompleteOCLStandaloneSetup.doSetup();
 		OCLstdlib.install();
 	}


 	override protected doPropertiesConfiguration(OCL ocl) {
 		super.doPropertiesConfiguration(ocl);
 		val genModelURI = getGenModelURI(projectName, genModelFile);
 		val genModelResource = getGenModelResource(ocl, genModelURI);
 		val genPackage = getGenPackage(genModelResource);

 		var helper = new GenPackageHelper(genPackage);
 		if (!lookupPackageName.isDefined || lookupPackageName.length == 0) {
 			lookupPackageName = helper.modelPackageName + ".lookup"
 		}

 		if (isDerived()) {
 			val superGenModelURI = getGenModelURI(superProjectName, superGenModelFile);
 			val superGenModelResource = getGenModelResource(ocl, superGenModelURI);
 			val superGenPackage = getGenPackage(superGenModelResource);
 			helper = new GenPackageHelper(superGenPackage)
 			if (!superLookupPackageName.isDefined || superLookupPackageName.length == 0) {
 				superLookupPackageName = helper.modelPackageName + ".lookup"
 			}

 			val baseGenModelURI = getGenModelURI(baseProjectName, baseGenModelFile);
 			val baseGenModelResource = getGenModelResource(ocl, baseGenModelURI);
 			val baseGenPackage = getGenPackage(baseGenModelResource);
 			helper = new GenPackageHelper(baseGenPackage);
 			if (!baseLookupPackageName.isDefined || baseLookupPackageName.length == 0) {
 				baseLookupPackageName = helper.modelPackageName + ".lookup"
 			}
 		} else {
 			if (!baseLookupPackageName.isDefined || baseLookupPackageName.length == 0) {
 				baseLookupPackageName = lookupPackageName;
 			}
 		}
 	}

 	@SuppressWarnings("null")
 	protected def doGenerateVisitors(/*@NonNull*/ GenPackage genPackage) {
 		LookupCodeGenerator.generate(genPackage, superGenPackage, baseGenPackage, projectName, lookupFilePath,
 				lookupPackageName, lookupPackageName,null); // FIXME
 	}

 	protected def void generateAutoLookupResultItf(/*@NonNull*/ EPackage ePackage) {
 		var boolean isDerived = isDerived();
 		if (!isDerived) {
 			var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + projectPrefix + "LookupResult.java");
 			writer.append('''
 	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

 	import java.util.List;

 	import org.eclipse.jdt.annotation.NonNull;
 	import org.eclipse.jdt.annotation.Nullable;

 	/**
 	 * The lookup result returned by the name lookup solver
 	 */
 	public interface «projectPrefix»LookupResult<NE> {

 		@Nullable
 		NE getSingleResult();

 		@NonNull
 		List<NE> getAllResults();

 		int size();
 	}
 			''');
 			writer.close();
 		}
 	}

 	protected def void generateAutoLookupResultClass(/*@NonNull*/ EPackage ePackage) {
 		var boolean isDerived = isDerived();
 		if (!isDerived) {
 			var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + projectPrefix + "LookupResultImpl.java");
 			writer.append('''
 	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

 	import java.util.ArrayList;
 	import java.util.Collections;
 	import java.util.List;

 	import org.eclipse.jdt.annotation.NonNull;
 	import org.eclipse.jdt.annotation.Nullable;

 	public class «projectPrefix»LookupResultImpl<NE> implements «projectPrefix»LookupResult<NE> {

 		private @NonNull List<NE> results = new ArrayList<NE>();

 		public «projectPrefix»LookupResultImpl(List<NE> results){
 			this.results.addAll(results);
 		}

 		@Override
 		public @NonNull List<NE> getAllResults() {
 			return Collections.unmodifiableList(results);
 		}

 		@Override
 		public @Nullable NE getSingleResult() {
 			return results.size() == 0 ? null : results.get(0);
 		}

 		@Override
 		public int size() {
 			return results.size();
 		}
 	}
 			''');
 			writer.close();
 		}
 	}

 	protected def void generateAutoLookupFilterItf(/*@NonNull*/ EPackage ePackage) {
 		val boolean isDerived = isDerived();
 		if (!isDerived) {
 			val itfName =  '''«projectPrefix»LookupFilter'''
 			val MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + itfName + ".java");
 			writer.append('''
 	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

 	import org.eclipse.jdt.annotation.NonNull;
 	import «modelPackageName».NamedElement;

 	/**
 	 *
 	 */
 	public interface «itfName» {

 		boolean matches(@NonNull NamedElement namedElement);

 	}
 			''');
 			writer.close();
 		}
 	}

 	protected def void generateAutoLookupFilterClass(/*@NonNull*/ EPackage ePackage) {
 		val boolean isDerived = isDerived();
 		if (!isDerived) {
 			val className =  '''Abstract«projectPrefix»LookupFilter''';
 			val itfName =  '''«projectPrefix»LookupFilter'''
 			val MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + className + ".java");
 			writer.append('''
 	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

 	import org.eclipse.jdt.annotation.NonNull;
 	import «modelPackageName».NamedElement;

 	/**
 	 *
 	 */
 	public abstract class «className»<C extends NamedElement> implements «itfName» {

 		@NonNull private Class<C> _class;

 		public «className»(@NonNull Class<C> _class) {
 			this._class = _class;
 		}

 		@SuppressWarnings("unchecked")
 		@Override
 		public boolean matches(@NonNull NamedElement namedElement) {
 			return _class.isInstance(namedElement) && _matches((C)namedElement);
 		}

 		abstract protected Boolean _matches(@NonNull C element);
 	}
 			''');
 			writer.close();
 		}
 	}
 	protected def void generateSingleResultLookupEnvironment(/*@NonNull*/ EPackage ePackage) {

 		var boolean isDerived = isDerived();
 		var className = projectPrefix + "SingleResultLookupEnvironment";
 		if (!isDerived) {
 			var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + className+ ".java");
 			writer.append('''
 	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

 	import java.util.ArrayList;
 	import java.util.Collection;
 	import java.util.List;

 	import org.eclipse.emf.ecore.EClass;
 	import org.eclipse.jdt.annotation.NonNull;
 	import org.eclipse.jdt.annotation.Nullable;
 	import org.eclipse.ocl.pivot.evaluation.Executor;

 	import «modelPackageName».NamedElement;
 	import «lookupPackageName».LookupEnvironment;
 	import «lookupPackageName».impl.LookupEnvironmentImpl;

 	public class «className» extends LookupEnvironmentImpl   {

 		private @NonNull Executor executor;
 		private @NonNull String name;
 		private @NonNull EClass typeFilter;
 		private @Nullable «projectPrefix»LookupFilter expFilter;

 		public «className»(@NonNull Executor executor, /*@NonNull*/ EClass typeFilter, /*@NonNull*/ String name,  @Nullable «projectPrefix»LookupFilter expFilter) {
 			assert typeFilter != null;
 			assert name != null;
 			this.executor = executor;
 			this.name = name;
 			this.typeFilter = typeFilter;
 			this.expFilter = expFilter;
 		}

 		public «className»(@NonNull Executor executor, /*@NonNull*/ EClass typeFilter, /*@NonNull*/ String name) {
 			this(executor, typeFilter, name, null);
 		}

 		@Override
 		@NonNull
 		public Executor getExecutor() {
 			return executor;
 		}

 		@Override
 		public boolean hasFinalResult() {
 			for (NamedElement element : getNamedElements()) {
 				if (name.equals(element.getName())) {
 					return true;
 				}
 			}
 			return false;
 		}

 		@Override
 		@NonNull
 		public LookupEnvironment addElement(@Nullable NamedElement namedElement) {
 			if (namedElement != null) {
 				if (name.equals(namedElement.getName())) {
 					if (typeFilter.isInstance(namedElement)) {
 					    «projectPrefix»LookupFilter expFilter2 = expFilter;
 						if (expFilter2 == null || expFilter2.matches(namedElement)) {
 							List<NamedElement> elements = getNamedElements();
 							if (!elements.contains(namedElement)) { 	// FIXME use a set ?
 								elements.add(namedElement);
 							}
 						}
 					}
 				}
 			}
 			return this;
 		}

 		@Override
 		@NonNull
 		public <NE extends NamedElement > LookupEnvironment addElements(
 				@Nullable Collection<NE> namedElements) {

 			if (namedElements != null) {
 				for (NamedElement namedElement : namedElements) {
 					addElement(namedElement);
 				}
 			}
 			return this;
 		}

 		@SuppressWarnings("unchecked")
 		public <NE extends NamedElement> List<NE> getNamedElementsByKind(Class<NE> class_) {
 			List<NE> result = new ArrayList<NE>();
 			for (NamedElement namedElement : getNamedElements()) {
 				if (class_.isAssignableFrom(namedElement.getClass())) {
 					result.add((NE)namedElement);
 				}
 			}
 			return result;
 		}
 	}
 			''');
 			writer.close();
 		}
 	}

 	protected def void generateAutoLookupSolver(GenPackage genPackage, GenPackage basePackage) {
 		var EPackage ePackage = genPackage.getEcorePackage;
 		var String fqPackageItf = genModelHelper.getQualifiedPackageInterfaceName(ePackage)
 		var List<Operation> lookupOps = basePackage.lookupMethods;
 		var boolean isDerived = isDerived();
 		var String className = projectPrefix + "LookupSolver";
 		var String superClassName = superProjectPrefix + "LookupSolver";
 		var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + className + ".java");
 		writer.append('''
 	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

 	import org.eclipse.jdt.annotation.NonNull;
 	import org.eclipse.ocl.pivot.evaluation.Executor;
 	«FOR typeName : lookupOps.getLookupTypeNames("Unqualified")»
 	import «visitorPackageName».«projectPrefix»Unqualified«typeName»LookupVisitor;
 	«ENDFOR»
 	«FOR typeName : lookupOps.getLookupTypeNames("Exported")»
 	import «visitorPackageName».«projectPrefix»Exported«typeName»LookupVisitor;
 	«ENDFOR»
 	«FOR typeName : lookupOps.getLookupTypeNames("Qualified")»
 	import «visitorPackageName».«projectPrefix»Qualified«typeName»LookupVisitor;
 	«ENDFOR»

 	«IF isDerived»
 	import «superLookupPackageName».util.«superClassName»;
 	import «baseLookupPackageName».util.«basePackage.prefix»LookupResult;
 	import «baseLookupPackageName».util.«basePackage.prefix»LookupResultImpl;
 	import «baseLookupPackageName».util.«basePackage.prefix»SingleResultLookupEnvironment;
 	«ENDIF»

 	public class «className»«IF isDerived» extends «superClassName»«ENDIF» {

 		«IF !isDerived»protected final @NonNull Executor executor;

 		«ENDIF»
 		public «className» (@NonNull Executor executor) {
 			«IF isDerived»
 			super(executor);
 			«ELSE»
 			this.executor = executor;
 			«ENDIF»
 		}

 		«FOR op : lookupOps»
 		«val opName = op.name»
 		«val isExportedLookup = op.exportedLookupOperation»
 		«val lookupVisitorName = op.getLookupVisitorName(op.type.name)»
 		«val hasAdditionalFilter = op.hasAdditionalFilterArgs»
 		«val lookupVars = op.getLookupArgs»
 		«val typeFQName = getTypeFQName(op.type)»
 		«val typeLiteral = getTypeLiteral(op.type)»

 		public «basePackage.prefix»LookupResult<«typeFQName»> «opName»(«getTypeFQName(op.owningClass)» context«FOR param:op.ownedParameters», «getTypeFQName(param.type)» «param.name»«ENDFOR») {
 			«IF hasAdditionalFilter»
 			«op.type.name»Filter filter = new «op.type.name»Filter(executor, «op.getFilterArgs»);
 			«ENDIF»
 			«basePackage.prefix»SingleResultLookupEnvironment _lookupEnv = new «basePackage.prefix»SingleResultLookupEnvironment(executor, «fqPackageItf».Literals.«typeLiteral»«lookupVars»);
 			«lookupVisitorName» _lookupVisitor = new «lookupVisitorName»(_lookupEnv«IF isExportedLookup», importer«ENDIF»);
 			context.accept(_lookupVisitor);
 			return new «basePackage.prefix»LookupResultImpl<«typeFQName»>
 					(_lookupEnv.getNamedElementsByKind(«typeFQName».class));
 		}
 		«ENDFOR»
 	}
 		''');
 		writer.close();
 	}

 	protected def void generateAutoCommonLookupVisitor(EPackage ePackage) {
 		var String fqPackageItf = genModelHelper.getQualifiedPackageInterfaceName(ePackage)

 		var boolean isDerived = isDerived();
 		var String visitorName = '''Abstract«projectPrefix»CommonLookupVisitor''';
 		var String superVisitorName = '''Abstract«superProjectPrefix»CommonLookupVisitor''';
 		var String superClassName = '''AbstractExtending«IF isDerived»«projectPrefix»«ENDIF»Visitor'''
 		var MergeWriter writer = new MergeWriter(outputFolder + visitorName + ".java");
 		writer.append('''
 	«ePackage.generateHeaderWithTemplate(visitorPackageName)»
 	import org.eclipse.jdt.annotation.NonNull;
 	import org.eclipse.jdt.annotation.Nullable;
 	import org.eclipse.ocl.pivot.internal.evaluation.EvaluationCache;
 	«IF !isDerived»
 	import org.eclipse.ocl.pivot.internal.evaluation.ExecutorInternal.ExecutorInternalExtension;
 	«ENDIF»

 	import «baseLookupPackageName».LookupEnvironment;
 	import «visitablePackageName».«visitableClassName»;
 	«IF isDerived»
 	import «superVisitorPackageName».«superVisitorName»;
 	«ENDIF»

 	public abstract class «visitorName»
 		extends «superClassName»<@Nullable LookupEnvironment, @NonNull LookupEnvironment> {

 		«IF !isDerived»protected final @NonNull EvaluationCache evaluationCache;«ENDIF»
 		«IF isDerived»private «superVisitorName» delegate;«ENDIF»

 		protected «visitorName»(@NonNull LookupEnvironment context) {
 			super(context);
 			«IF !isDerived»this.evaluationCache = ((ExecutorInternalExtension)context.getExecutor()).getEvaluationCache();«ENDIF»
 			«IF isDerived»this.delegate = createSuperLangVisitor();«ENDIF»
 		}

 		@Override
 		public final LookupEnvironment visiting(@NonNull Visitable visitable) {
 			«IF isDerived»
 			return «fqPackageItf».eINSTANCE == visitable.eClass().getEPackage()
 				? doVisiting(visitable)
 				: visitable.accept(getSuperLangVisitor());
 			«ELSE»
 			return doVisiting(visitable);
 			«ENDIF»
 		}

 		«IF isDerived»
 		protected «superVisitorName» getSuperLangVisitor(){
 			if (delegate == null) {
 				delegate = createSuperLangVisitor();
 			}
 			return delegate;
 		}
 		«ENDIF»

 		abstract protected LookupEnvironment doVisiting(@NonNull Visitable visitable);

 		«IF isDerived»abstract protected «superVisitorName»  createSuperLangVisitor();«ENDIF»
 	}
 		''')
 		writer.close();
 	}

 	override generateVisitors(GenPackage genPackage) {
 		genModelHelper = createGenModelHelper(genPackage);
 		lookupArtifactsJavaPackage = lookupPackageName + ".util";
 		lookupArtifactsOutputFolder = modelFolder + lookupArtifactsJavaPackage.replace('.', '/') + "/";

 		var EPackage ePackage = genPackage.getEcorePackage();

 		// Some lookup artefacts
 		ePackage.generateAutoLookupResultClass;
 		ePackage.generateAutoLookupResultItf;
 		ePackage.generateAutoLookupFilterItf;
 		ePackage.generateAutoLookupFilterClass;
 		ePackage.generateSingleResultLookupEnvironment;
 		genPackage.generateAutoLookupSolver(baseGenPackage);

 		// Visitors related generation
 		ePackage.generateAutoCommonLookupVisitor;
 		doGenerateVisitors(genPackage);
 	}

 	private def List<Operation> getLookupMethods(GenPackage genPackage) {

 		var List<Operation> result = new ArrayList<Operation>;
 		var EnvironmentFactory envFact = PivotUtilInternal.getEnvironmentFactory(genPackage.getEcorePackage.eResource)
 		for (oclPackage : LookupCGUtil.getTargetPackages(genPackage, envFact, lookupFilePath, projectName)) {
 			for (oclClass : oclPackage.ownedClasses) {
 				for (oclOp : oclClass.ownedOperations) {
 					if (oclOp.isLookupOperation) {
 						result.add(oclOp);
 					}
 				}
 			}
 		}
 		return result;
 	}

 	private def Set<String> getLookupTypeNames(List<Operation> lookupOps, String lookupProtocol) {

 		val result = newHashSet();
 		for (op : lookupOps) {
 			if (op.name.contains(lookupProtocol)){
 				result.add(op.type.name);
 			}
 		}
 		return result;
 	}

 	private def boolean isLookupOperation(Operation op){
 		// internal lookup ops...
 		if (!op.name.startsWith("_lookup")) {
 			return false;
 		}

 		// ...which don't have the env parameter
 		// FIXME more robust check of the parameter
 		for (param : op.ownedParameters) {
 			if ("env".equals(param.name)) {
 				return false
 			}
 		}

 		return true;
 	}

 	private def boolean isExportedLookupOperation(Operation op) {
 		isLookupOperation(op) && op.name.contains("Exported") // FIXME more robust check?
 	}

 	private def GenModelHelper createGenModelHelper(GenPackage genPackage) {
 		var PivotMetamodelManager mManager = PivotUtilInternal.getEnvironmentFactory(genPackage.getEcorePackage().eResource).metamodelManager;
 		return new AbstractGenModelHelper(mManager);
 	}

 	private def String getTypeLiteral(Type type) {
 		var GenClassifier genClassifier = genModelHelper.getGenClassifier(type as Class);
 		return ClassUtil.nonNullState(genClassifier).classifierID;
 	}

 	private def String getTypeFQName(Type type) {
 		return if (type instanceof CollectionType) '''java.util.List<«getTypeFQName(type.elementType)»>'''
 			else genModelHelper.getEcoreInterfaceName(type as Class)
 	}

 	private def String getLookupVisitorName(Operation op, String typeName) {

 		if (op.name.contains("Qualified")) '''«projectPrefix»Qualified«typeName»LookupVisitor'''
 		else if (op.name.contains("Exported")) '''«projectPrefix»Exported«typeName»LookupVisitor'''
 		else '''«projectPrefix»Unqualified«typeName»LookupVisitor''';
 	}


 	private def boolean hasAdditionalFilterArgs(Operation op) {
 		val params = op.ownedParameters;
 		if (op.isExportedLookupOperation) params.size() > 2 else params.size() > 1;
 	}

 	private def String getLookupArgs(Operation op) {
 		val params = op.ownedParameters
 		val nameParam = if (op.isExportedLookupOperation) params.get(1) else params.get(0);
 		''',«nameParam.name»«IF op.hasAdditionalFilterArgs»,filter«ENDIF»'''
 	}

 	// We assume we are dealing with the the exported element lookup op
 	private def String getFilterArgs(Operation op) {
 		val sb = new StringBuffer();
 		val filterArgsIndex = if (op.isExportedLookupOperation) 2 else 1;
 		val params = op.ownedParameters
 		var first=true;
 		for (var i = filterArgsIndex; i < params.size; i++) {
 			if (first) {
 				first = false
 			} else {
 				sb.append(',');
 			}
 			sb.append('''«params.get(i).name»''');
 		}
 		sb.toString();
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2015 Willink Transformations, University of York 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:
	* Adolfo Sanchez-Barbudo Herrera (University of York) - initial API and implementation
	*******************************************************************************/
	package org.eclipse.ocl.examples.autogen.xtend

	import java.util.ArrayList
	import java.util.List
	import org.eclipse.emf.codegen.ecore.genmodel.GenClassifier
	import org.eclipse.emf.codegen.ecore.genmodel.GenPackage
	import org.eclipse.emf.ecore.EPackage
	import org.eclipse.emf.mwe.core.issues.Issues
	import org.eclipse.ocl.examples.codegen.generator.AbstractGenModelHelper
	import org.eclipse.ocl.examples.codegen.generator.GenModelHelper
	import org.eclipse.ocl.pivot.Class
	import org.eclipse.ocl.pivot.Operation
	import org.eclipse.ocl.pivot.Type
	import org.eclipse.ocl.pivot.internal.manager.PivotMetamodelManager
	import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal
	import org.eclipse.ocl.pivot.utilities.ClassUtil
	import org.eclipse.ocl.pivot.utilities.EnvironmentFactory
	import org.eclipse.ocl.pivot.CollectionType
	import org.eclipse.ocl.pivot.utilities.OCL
	import org.eclipse.ocl.examples.build.utilities.GenPackageHelper
	import org.eclipse.ocl.examples.autogen.lookup.LookupCodeGenerator
	import org.eclipse.ocl.xtext.completeocl.CompleteOCLStandaloneSetup
	import org.eclipse.ocl.pivot.model.OCLstdlib
	import java.util.Set
	import org.eclipse.ocl.examples.autogen.lookup.LookupCGUtil
	import org.eclipse.ocl.examples.build.xtend.GenerateVisitorsXtend
	import org.eclipse.ocl.examples.build.xtend.MergeWriter

	class GenerateAutoLookupInfrastructureXtend extends GenerateVisitorsXtend
	{

	protected String lookupFilePath;
	// FIXME The lookupVisitor will be in the normal visitors folder, but all the artifacts generated by this component
	// will be in a different one
	protected String lookupArtifactsJavaPackage;
	protected String lookupArtifactsOutputFolder;
	protected String lookupPackageName;
	protected String superLookupPackageName
	protected String baseLookupPackageName
	protected GenModelHelper genModelHelper;

	override checkConfiguration(Issues issues) {
	super.checkConfiguration(issues);
	if (!isDefined(lookupFilePath)) {
	issues.addError(this, "lookupFilePath must be specified");
	}
	}

	/**
	* The path inside the projectName to the Complete OCL file which contains the
	* name resolution description (e.g. "model/NameResolution.ocl"). It
	* can't be null
	*/
	def setLookupFilePath(String lookupFilePath) {
	this.lookupFilePath = lookupFilePath;
	}

	def setLookupPackageName(String lookupPackageName) {
	this.lookupPackageName = lookupPackageName;
	}

	def setSuperLookupPackageName(String superLookupPackageName) {
	this.superLookupPackageName = superLookupPackageName;
	}

	def setBaseLookupPackageName(String baseLookupPackageName) {
	this.baseLookupPackageName = baseLookupPackageName;
	}

	protected override doSetup() {
	CompleteOCLStandaloneSetup.doSetup();
	OCLstdlib.install();
	}


	override protected doPropertiesConfiguration(OCL ocl) {
	super.doPropertiesConfiguration(ocl);
	val genModelURI = getGenModelURI(projectName, genModelFile);
	val genModelResource = getGenModelResource(ocl, genModelURI);
	val genPackage = getGenPackage(genModelResource);

	var helper = new GenPackageHelper(genPackage);
	if (!lookupPackageName.isDefined \|\| lookupPackageName.length == 0) {
	lookupPackageName = helper.modelPackageName + ".lookup"
	}

	if (isDerived()) {
	val superGenModelURI = getGenModelURI(superProjectName, superGenModelFile);
	val superGenModelResource = getGenModelResource(ocl, superGenModelURI);
	val superGenPackage = getGenPackage(superGenModelResource);
	helper = new GenPackageHelper(superGenPackage)
	if (!superLookupPackageName.isDefined \|\| superLookupPackageName.length == 0) {
	superLookupPackageName = helper.modelPackageName + ".lookup"
	}

	val baseGenModelURI = getGenModelURI(baseProjectName, baseGenModelFile);
	val baseGenModelResource = getGenModelResource(ocl, baseGenModelURI);
	val baseGenPackage = getGenPackage(baseGenModelResource);
	helper = new GenPackageHelper(baseGenPackage);
	if (!baseLookupPackageName.isDefined \|\| baseLookupPackageName.length == 0) {
	baseLookupPackageName = helper.modelPackageName + ".lookup"
	}
	} else {
	if (!baseLookupPackageName.isDefined \|\| baseLookupPackageName.length == 0) {
	baseLookupPackageName = lookupPackageName;
	}
	}
	}

	@SuppressWarnings("null")
	protected def doGenerateVisitors(/@NonNull/ GenPackage genPackage) {
	LookupCodeGenerator.generate(genPackage, superGenPackage, baseGenPackage, projectName, lookupFilePath,
	lookupPackageName, lookupPackageName,null); // FIXME
	}

	protected def void generateAutoLookupResultItf(/@NonNull/ EPackage ePackage) {
	var boolean isDerived = isDerived();
	if (!isDerived) {
	var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + projectPrefix + "LookupResult.java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

	import java.util.List;

	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;

	/**
	* The lookup result returned by the name lookup solver
	*/
	public interface «projectPrefix»LookupResult<NE> {

	@Nullable
	NE getSingleResult();

	@NonNull
	List<NE> getAllResults();

	int size();
	}
	''');
	writer.close();
	}
	}

	protected def void generateAutoLookupResultClass(/@NonNull/ EPackage ePackage) {
	var boolean isDerived = isDerived();
	if (!isDerived) {
	var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + projectPrefix + "LookupResultImpl.java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;

	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;

	public class «projectPrefix»LookupResultImpl<NE> implements «projectPrefix»LookupResult<NE> {

	private @NonNull List<NE> results = new ArrayList<NE>();

	public «projectPrefix»LookupResultImpl(List<NE> results){
	this.results.addAll(results);
	}

	@Override
	public @NonNull List<NE> getAllResults() {
	return Collections.unmodifiableList(results);
	}

	@Override
	public @Nullable NE getSingleResult() {
	return results.size() == 0 ? null : results.get(0);
	}

	@Override
	public int size() {
	return results.size();
	}
	}
	''');
	writer.close();
	}
	}

	protected def void generateAutoLookupFilterItf(/@NonNull/ EPackage ePackage) {
	val boolean isDerived = isDerived();
	if (!isDerived) {
	val itfName = '''«projectPrefix»LookupFilter'''
	val MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + itfName + ".java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

	import org.eclipse.jdt.annotation.NonNull;
	import «modelPackageName».NamedElement;

	/**
	*
	*/
	public interface «itfName» {

	boolean matches(@NonNull NamedElement namedElement);

	}
	''');
	writer.close();
	}
	}

	protected def void generateAutoLookupFilterClass(/@NonNull/ EPackage ePackage) {
	val boolean isDerived = isDerived();
	if (!isDerived) {
	val className = '''Abstract«projectPrefix»LookupFilter''';
	val itfName = '''«projectPrefix»LookupFilter'''
	val MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + className + ".java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

	import org.eclipse.jdt.annotation.NonNull;
	import «modelPackageName».NamedElement;

	/**
	*
	*/
	public abstract class «className»<C extends NamedElement> implements «itfName» {

	@NonNull private Class<C> _class;

	public «className»(@NonNull Class<C> _class) {
	this._class = _class;
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean matches(@NonNull NamedElement namedElement) {
	return _class.isInstance(namedElement) && _matches((C)namedElement);
	}

	abstract protected Boolean _matches(@NonNull C element);
	}
	''');
	writer.close();
	}
	}
	protected def void generateSingleResultLookupEnvironment(/@NonNull/ EPackage ePackage) {

	var boolean isDerived = isDerived();
	var className = projectPrefix + "SingleResultLookupEnvironment";
	if (!isDerived) {
	var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + className+ ".java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;

	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.ocl.pivot.evaluation.Executor;

	import «modelPackageName».NamedElement;
	import «lookupPackageName».LookupEnvironment;
	import «lookupPackageName».impl.LookupEnvironmentImpl;

	public class «className» extends LookupEnvironmentImpl {

	private @NonNull Executor executor;
	private @NonNull String name;
	private @NonNull EClass typeFilter;
	private @Nullable «projectPrefix»LookupFilter expFilter;

	public «className»(@NonNull Executor executor, /@NonNull/ EClass typeFilter, /@NonNull/ String name, @Nullable «projectPrefix»LookupFilter expFilter) {
	assert typeFilter != null;
	assert name != null;
	this.executor = executor;
	this.name = name;
	this.typeFilter = typeFilter;
	this.expFilter = expFilter;
	}

	public «className»(@NonNull Executor executor, /@NonNull/ EClass typeFilter, /@NonNull/ String name) {
	this(executor, typeFilter, name, null);
	}

	@Override
	@NonNull
	public Executor getExecutor() {
	return executor;
	}

	@Override
	public boolean hasFinalResult() {
	for (NamedElement element : getNamedElements()) {
	if (name.equals(element.getName())) {
	return true;
	}
	}
	return false;
	}

	@Override
	@NonNull
	public LookupEnvironment addElement(@Nullable NamedElement namedElement) {
	if (namedElement != null) {
	if (name.equals(namedElement.getName())) {
	if (typeFilter.isInstance(namedElement)) {
	«projectPrefix»LookupFilter expFilter2 = expFilter;
	if (expFilter2 == null \|\| expFilter2.matches(namedElement)) {
	List<NamedElement> elements = getNamedElements();
	if (!elements.contains(namedElement)) { // FIXME use a set ?
	elements.add(namedElement);
	}
	}
	}
	}
	}
	return this;
	}

	@Override
	@NonNull
	public <NE extends NamedElement > LookupEnvironment addElements(
	@Nullable Collection<NE> namedElements) {

	if (namedElements != null) {
	for (NamedElement namedElement : namedElements) {
	addElement(namedElement);
	}
	}
	return this;
	}

	@SuppressWarnings("unchecked")
	public <NE extends NamedElement> List<NE> getNamedElementsByKind(Class<NE> class_) {
	List<NE> result = new ArrayList<NE>();
	for (NamedElement namedElement : getNamedElements()) {
	if (class_.isAssignableFrom(namedElement.getClass())) {
	result.add((NE)namedElement);
	}
	}
	return result;
	}
	}
	''');
	writer.close();
	}
	}

	protected def void generateAutoLookupSolver(GenPackage genPackage, GenPackage basePackage) {
	var EPackage ePackage = genPackage.getEcorePackage;
	var String fqPackageItf = genModelHelper.getQualifiedPackageInterfaceName(ePackage)
	var List<Operation> lookupOps = basePackage.lookupMethods;
	var boolean isDerived = isDerived();
	var String className = projectPrefix + "LookupSolver";
	var String superClassName = superProjectPrefix + "LookupSolver";
	var MergeWriter writer = new MergeWriter(lookupArtifactsOutputFolder + className + ".java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(lookupArtifactsJavaPackage)»

	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.ocl.pivot.evaluation.Executor;
	«FOR typeName : lookupOps.getLookupTypeNames("Unqualified")»
	import «visitorPackageName».«projectPrefix»Unqualified«typeName»LookupVisitor;
	«ENDFOR»
	«FOR typeName : lookupOps.getLookupTypeNames("Exported")»
	import «visitorPackageName».«projectPrefix»Exported«typeName»LookupVisitor;
	«ENDFOR»
	«FOR typeName : lookupOps.getLookupTypeNames("Qualified")»
	import «visitorPackageName».«projectPrefix»Qualified«typeName»LookupVisitor;
	«ENDFOR»

	«IF isDerived»
	import «superLookupPackageName».util.«superClassName»;
	import «baseLookupPackageName».util.«basePackage.prefix»LookupResult;
	import «baseLookupPackageName».util.«basePackage.prefix»LookupResultImpl;
	import «baseLookupPackageName».util.«basePackage.prefix»SingleResultLookupEnvironment;
	«ENDIF»

	public class «className»«IF isDerived» extends «superClassName»«ENDIF» {

	«IF !isDerived»protected final @NonNull Executor executor;

	«ENDIF»
	public «className» (@NonNull Executor executor) {
	«IF isDerived»
	super(executor);
	«ELSE»
	this.executor = executor;
	«ENDIF»
	}

	«FOR op : lookupOps»
	«val opName = op.name»
	«val isExportedLookup = op.exportedLookupOperation»
	«val lookupVisitorName = op.getLookupVisitorName(op.type.name)»
	«val hasAdditionalFilter = op.hasAdditionalFilterArgs»
	«val lookupVars = op.getLookupArgs»
	«val typeFQName = getTypeFQName(op.type)»
	«val typeLiteral = getTypeLiteral(op.type)»

	public «basePackage.prefix»LookupResult<«typeFQName»> «opName»(«getTypeFQName(op.owningClass)» context«FOR param:op.ownedParameters», «getTypeFQName(param.type)» «param.name»«ENDFOR») {
	«IF hasAdditionalFilter»
	«op.type.name»Filter filter = new «op.type.name»Filter(executor, «op.getFilterArgs»);
	«ENDIF»
	«basePackage.prefix»SingleResultLookupEnvironment _lookupEnv = new «basePackage.prefix»SingleResultLookupEnvironment(executor, «fqPackageItf».Literals.«typeLiteral»«lookupVars»);
	«lookupVisitorName» _lookupVisitor = new «lookupVisitorName»(_lookupEnv«IF isExportedLookup», importer«ENDIF»);
	context.accept(_lookupVisitor);
	return new «basePackage.prefix»LookupResultImpl<«typeFQName»>
	(_lookupEnv.getNamedElementsByKind(«typeFQName».class));
	}
	«ENDFOR»
	}
	''');
	writer.close();
	}

	protected def void generateAutoCommonLookupVisitor(EPackage ePackage) {
	var String fqPackageItf = genModelHelper.getQualifiedPackageInterfaceName(ePackage)

	var boolean isDerived = isDerived();
	var String visitorName = '''Abstract«projectPrefix»CommonLookupVisitor''';
	var String superVisitorName = '''Abstract«superProjectPrefix»CommonLookupVisitor''';
	var String superClassName = '''AbstractExtending«IF isDerived»«projectPrefix»«ENDIF»Visitor'''
	var MergeWriter writer = new MergeWriter(outputFolder + visitorName + ".java");
	writer.append('''
	«ePackage.generateHeaderWithTemplate(visitorPackageName)»
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.ocl.pivot.internal.evaluation.EvaluationCache;
	«IF !isDerived»
	import org.eclipse.ocl.pivot.internal.evaluation.ExecutorInternal.ExecutorInternalExtension;
	«ENDIF»

	import «baseLookupPackageName».LookupEnvironment;
	import «visitablePackageName».«visitableClassName»;
	«IF isDerived»
	import «superVisitorPackageName».«superVisitorName»;
	«ENDIF»

	public abstract class «visitorName»
	extends «superClassName»<@Nullable LookupEnvironment, @NonNull LookupEnvironment> {

	«IF !isDerived»protected final @NonNull EvaluationCache evaluationCache;«ENDIF»
	«IF isDerived»private «superVisitorName» delegate;«ENDIF»

	protected «visitorName»(@NonNull LookupEnvironment context) {
	super(context);
	«IF !isDerived»this.evaluationCache = ((ExecutorInternalExtension)context.getExecutor()).getEvaluationCache();«ENDIF»
	«IF isDerived»this.delegate = createSuperLangVisitor();«ENDIF»
	}

	@Override
	public final LookupEnvironment visiting(@NonNull Visitable visitable) {
	«IF isDerived»
	return «fqPackageItf».eINSTANCE == visitable.eClass().getEPackage()
	? doVisiting(visitable)
	: visitable.accept(getSuperLangVisitor());
	«ELSE»
	return doVisiting(visitable);
	«ENDIF»
	}

	«IF isDerived»
	protected «superVisitorName» getSuperLangVisitor(){
	if (delegate == null) {
	delegate = createSuperLangVisitor();
	}
	return delegate;
	}
	«ENDIF»

	abstract protected LookupEnvironment doVisiting(@NonNull Visitable visitable);

	«IF isDerived»abstract protected «superVisitorName» createSuperLangVisitor();«ENDIF»
	}
	''')
	writer.close();
	}

	override generateVisitors(GenPackage genPackage) {
	genModelHelper = createGenModelHelper(genPackage);
	lookupArtifactsJavaPackage = lookupPackageName + ".util";
	lookupArtifactsOutputFolder = modelFolder + lookupArtifactsJavaPackage.replace('.', '/') + "/";

	var EPackage ePackage = genPackage.getEcorePackage();

	// Some lookup artefacts
	ePackage.generateAutoLookupResultClass;
	ePackage.generateAutoLookupResultItf;
	ePackage.generateAutoLookupFilterItf;
	ePackage.generateAutoLookupFilterClass;
	ePackage.generateSingleResultLookupEnvironment;
	genPackage.generateAutoLookupSolver(baseGenPackage);

	// Visitors related generation
	ePackage.generateAutoCommonLookupVisitor;
	doGenerateVisitors(genPackage);
	}

	private def List<Operation> getLookupMethods(GenPackage genPackage) {

	var List<Operation> result = new ArrayList<Operation>;
	var EnvironmentFactory envFact = PivotUtilInternal.getEnvironmentFactory(genPackage.getEcorePackage.eResource)
	for (oclPackage : LookupCGUtil.getTargetPackages(genPackage, envFact, lookupFilePath, projectName)) {
	for (oclClass : oclPackage.ownedClasses) {
	for (oclOp : oclClass.ownedOperations) {
	if (oclOp.isLookupOperation) {
	result.add(oclOp);
	}
	}
	}
	}
	return result;
	}

	private def Set<String> getLookupTypeNames(List<Operation> lookupOps, String lookupProtocol) {

	val result = newHashSet();
	for (op : lookupOps) {
	if (op.name.contains(lookupProtocol)){
	result.add(op.type.name);
	}
	}
	return result;
	}

	private def boolean isLookupOperation(Operation op){
	// internal lookup ops...
	if (!op.name.startsWith("_lookup")) {
	return false;
	}

	// ...which don't have the env parameter
	// FIXME more robust check of the parameter
	for (param : op.ownedParameters) {
	if ("env".equals(param.name)) {
	return false
	}
	}

	return true;
	}

	private def boolean isExportedLookupOperation(Operation op) {
	isLookupOperation(op) && op.name.contains("Exported") // FIXME more robust check?
	}

	private def GenModelHelper createGenModelHelper(GenPackage genPackage) {
	var PivotMetamodelManager mManager = PivotUtilInternal.getEnvironmentFactory(genPackage.getEcorePackage().eResource).metamodelManager;
	return new AbstractGenModelHelper(mManager);
	}

	private def String getTypeLiteral(Type type) {
	var GenClassifier genClassifier = genModelHelper.getGenClassifier(type as Class);
	return ClassUtil.nonNullState(genClassifier).classifierID;
	}

	private def String getTypeFQName(Type type) {
	return if (type instanceof CollectionType) '''java.util.List<«getTypeFQName(type.elementType)»>'''
	else genModelHelper.getEcoreInterfaceName(type as Class)
	}

	private def String getLookupVisitorName(Operation op, String typeName) {

	if (op.name.contains("Qualified")) '''«projectPrefix»Qualified«typeName»LookupVisitor'''
	else if (op.name.contains("Exported")) '''«projectPrefix»Exported«typeName»LookupVisitor'''
	else '''«projectPrefix»Unqualified«typeName»LookupVisitor''';
	}


	private def boolean hasAdditionalFilterArgs(Operation op) {
	val params = op.ownedParameters;
	if (op.isExportedLookupOperation) params.size() > 2 else params.size() > 1;
	}

	private def String getLookupArgs(Operation op) {
	val params = op.ownedParameters
	val nameParam = if (op.isExportedLookupOperation) params.get(1) else params.get(0);
	''',«nameParam.name»«IF op.hasAdditionalFilterArgs»,filter«ENDIF»'''
	}

	// We assume we are dealing with the the exported element lookup op
	private def String getFilterArgs(Operation op) {
	val sb = new StringBuffer();
	val filterArgsIndex = if (op.isExportedLookupOperation) 2 else 1;
	val params = op.ownedParameters
	var first=true;
	for (var i = filterArgsIndex; i < params.size; i++) {
	if (first) {
	first = false
	} else {
	sb.append(',');
	}
	sb.append('''«params.get(i).name»''');
	}
	sb.toString();
	}

	}