/*******************************************************************************
 * Copyright (c) 2013 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.build.xtend

import java.util.ArrayList
import java.util.Collections
import org.eclipse.emf.ecore.EObject
import org.eclipse.ocl.pivot.AnyType
import org.eclipse.ocl.pivot.Class
import org.eclipse.ocl.pivot.CollectionType
import org.eclipse.ocl.pivot.Comment
import org.eclipse.ocl.pivot.EnumerationLiteral
import org.eclipse.ocl.pivot.LambdaType
import org.eclipse.ocl.pivot.MapType
import org.eclipse.ocl.pivot.Model
import org.eclipse.ocl.pivot.Operation
import org.eclipse.ocl.pivot.Package
import org.eclipse.ocl.pivot.Parameter
import org.eclipse.ocl.pivot.Precedence
import org.eclipse.ocl.pivot.PrimitiveType
import org.eclipse.ocl.pivot.Property
import org.eclipse.ocl.pivot.TemplateBinding
import org.eclipse.ocl.pivot.TemplateParameter
import org.eclipse.ocl.pivot.TemplateParameterSubstitution
import org.eclipse.ocl.pivot.TemplateSignature
import org.eclipse.ocl.pivot.utilities.ClassUtil
import java.util.Collection
import org.eclipse.ocl.pivot.values.Unlimited

abstract class GenerateOCLCommonXtend extends GenerateOCLCommon
{
	protected def String declareClassTypes(/*@NonNull*/ Model root, /*@NonNull*/ Collection</*@NonNull*/ String> excludedEClassifierNames) {
		var pkge2classTypes = root.getSortedClassTypes();
		if (pkge2classTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2classTypes.keySet());
		'''
		«FOR pkge : sortedPackages»

			«FOR type : ClassUtil.nullFree(pkge2classTypes.get(pkge))»
				private final @NonNull «type.eClass.name» «type.getPrefixedSymbolNameWithoutNormalization("_" + type.partialName())» = create«type.
				eClass.name»("«type.name»");
			«ENDFOR»
		«ENDFOR»
		'''
	}

	protected def String declareCollectionTypes(Model root) {
		var pkge2collectionTypes = root.getSortedCollectionTypes();
		if (pkge2collectionTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2collectionTypes.keySet());
		'''
		«FOR pkge : sortedPackages»

			«FOR type : ClassUtil.nullFree(pkge2collectionTypes.get(pkge))»«var typeName = type.getPrefixedSymbolName("_" + type.getName() + "_" + type.getElementType().partialName() + (if (type.isIsNullFree()) "_NullFree" else "") )»
			«IF type.getOwnedSignature() !== null»
			private final @NonNull «type.eClass.name» «typeName» = create«type.eClass.name»("«type.name»"/*«type.elementType.name»*/, "«type.lower.toString()»", "«type.upper.toString()»"«IF type.getOwnedSignature() !== null»«FOR templateParameter : type.getOwnedSignature().getOwnedParameters()», «templateParameter.getSymbolName()»«ENDFOR»«ENDIF»);
			«ENDIF»
			«ENDFOR»
			«FOR type : ClassUtil.nullFree(pkge2collectionTypes.get(pkge))»«var typeName = type.getPrefixedSymbolName("_" + type.getName() + "_" + type.getElementType().partialName() + (if (type.isIsNullFree()) "_NullFree" else "") )»
			«IF type.getOwnedSignature() === null»
			private final @NonNull «type.eClass.name» «typeName» = create«type.eClass.name»(«type.getUnspecializedElement().getSymbolName()»);
			«ENDIF»
			«ENDFOR»
		«ENDFOR»
		'''
	}

	protected def String declareEnumerations(/*@NonNull*/ Model root) {
		var pkge2enumerations = root.getSortedEnumerations();
		if (pkge2enumerations.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2enumerations.keySet());
		'''
		
		«FOR pkge : sortedPackages»
			«FOR enumeration : ClassUtil.nullFree(pkge2enumerations.get(pkge))»
				«var enumerationName = enumeration.getPrefixedSymbolName("_" + enumeration.partialName())»
				private final @NonNull Enumeration «enumerationName» = createEnumeration("«enumeration.name»");
				«FOR enumerationLiteral : enumeration.ownedLiterals»
					private final @NonNull EnumerationLiteral «enumerationLiteral.getPrefixedSymbolName(
				"el_" + enumerationName + "_" + enumerationLiteral.name)» = createEnumerationLiteral("«enumerationLiteral.name»");
				«ENDFOR»
			«ENDFOR»
		«ENDFOR»
		'''
	}

	protected def String declareMapTypes(/*@NonNull*/ Model root) {
		var pkge2mapTypes = root.getSortedMapTypes();
		if (pkge2mapTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2mapTypes.keySet());
		'''

		«FOR pkge : sortedPackages»
			«FOR type : ClassUtil.nullFree(pkge2mapTypes.get(pkge))»
				«IF type.getOwnedSignature() !== null»
					private final @NonNull «type.eClass.name» «type.getPrefixedSymbolName("_" + type.getName() + "_" + type.getKeyType().partialName() + "_" + type.getValueType().partialName())» = create«type.
					eClass.name»("«type.name»"/*«type.keyType.name» «type.valueType.name»*/«IF type.getOwnedSignature() !== null»«FOR templateParameter : type.getOwnedSignature().getOwnedParameters()», «templateParameter.getSymbolName()»«ENDFOR»«ENDIF»);
				«ENDIF»
			«ENDFOR»
			«FOR type : ClassUtil.nullFree(pkge2mapTypes.get(pkge))»
				«IF type.getOwnedSignature() === null»
					private final @NonNull «type.eClass.name» «type.getPrefixedSymbolName("_" + type.getName() + "_" + type.getKeyType().partialName() + "_" + type.getValueType().partialName())» = create«type.
					eClass.name»(«type.getUnspecializedElement().getSymbolName()»);
				«ENDIF»
			«ENDFOR»
		«ENDFOR»
		'''
	}

	protected def String declarePrimitiveTypes(/*@NonNull*/ Model root) {
		var pkge2primitiveTypes = root.getSortedPrimitiveTypes();
		if (pkge2primitiveTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2primitiveTypes.keySet());
		'''
			«FOR pkge : sortedPackages»

				«FOR type : ClassUtil.nullFree(pkge2primitiveTypes.get(pkge))»
				private final @NonNull PrimitiveType «type.getPrefixedSymbolNameWithoutNormalization("_" + type.partialName())» = createPrimitiveType("«type.name»");
				«ENDFOR»
			«ENDFOR»
		'''
	}

	protected def String declareTupleTypes(/*@NonNull*/ Model root) {
		var tupleTypes = root.getSortedTupleTypes();
		if (tupleTypes.isEmpty()) return "";
		'''

			«FOR type : tupleTypes»
				private final @NonNull TupleType «type.getPrefixedSymbolName("_" + type.partialName())» = createTupleType("«type.name»",
				«FOR property : type.getSortedTupleParts() BEFORE ("\t") SEPARATOR (",\n\t")»
				createProperty("«property.name»", «property.type.getSymbolName()»)«ENDFOR»);
			«ENDFOR»
		'''
	}

	protected def String defineCoercions(/*@NonNull*/ Model root) {
		var allCoercions = root.getSortedCoercions();
		if (allCoercions.isEmpty()) return "";
		'''

			private void installCoercions() {
				List<Operation> ownedCoercions;
				Operation coercion;
				«FOR type : allCoercions.getSortedOwningTypes()»
					ownedCoercions = «type.getSymbolName()».getCoercions();
					«FOR coercion : (type as PrimitiveType).getSortedCoercions(allCoercions)»
						ownedCoercions.add(coercion = «coercion.getSymbolName()»);
						«IF coercion.bodyExpression !== null»
							createBodyExpression(operation, «coercion.type.getSymbolName()», "«coercion.bodyExpression.javaString()»");
						«ENDIF»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineClassTypes(/*@NonNull*/ Model root) {
		var pkge2classTypes = root.getSortedClassTypes();
		if (pkge2classTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2classTypes.keySet());
		'''

			private void installClassTypes() {
				List<Class> ownedClasses;
				List<Class> superClasses;
				Class type;
				«FOR pkge : sortedPackages»

					ownedClasses = «pkge.getSymbolName()».getOwnedClasses();
					«FOR type : ClassUtil.nullFree(pkge2classTypes.get(pkge))»
						ownedClasses.add(type = «type.getSymbolName()»);
						«IF type.isAbstract»
						type.setIsAbstract(true);
						«ENDIF»
						«IF !(type instanceof AnyType)»
							«type.emitSuperClasses("type")»
						«ENDIF»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineCollectionTypes(/*@NonNull*/ Model root) {
		// FIXME Probably need to interleave all specialized types in reverse dependency order
		var pkge2collectionTypes = root.getSortedCollectionTypes();
		if (pkge2collectionTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2collectionTypes.keySet());
		'''

			private void installCollectionTypes() {
				List<Class> ownedClasses;
				List<Class> superClasses;
				CollectionType type;
				«FOR pkge : sortedPackages»

					ownedClasses = «pkge.getSymbolName()».getOwnedClasses();
					«FOR type : ClassUtil.nullFree(pkge2collectionTypes.get(pkge))»
						ownedClasses.add(type = «type.getSymbolName()»);
						«IF type.isAbstract»
						type.setIsAbstract(true);
						«ENDIF»
						«IF type.lower.intValue() != 0»
						type.setLower(«type.lower.intValue()»);
						«ENDIF»
						«IF !(type.upper instanceof Unlimited)»
						type.setUpper(«type.upper.intValue()»);
						«ENDIF»
						«IF type.isNullFree»
						type.setIsNullFree(true);
						«ENDIF»
						«type.emitSuperClasses("type")»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineComments(/*@NonNull*/ Model root) {
		'''

			private void installComments() {
				«FOR pElement : root.getSortedCommentedElements()»
				«FOR pComment : pElement.getSortedComments()»
					installComment(«pElement.getSymbolName()», "«pComment.javaString()»");
				«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineEnumerations(/*@NonNull*/ Model root) {
		var pkge2enumerations = root.getSortedEnumerations();
		if (pkge2enumerations.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2enumerations.keySet());
		'''

			private void installEnumerations() {
				List<Class> ownedClasses;
				Enumeration type;
				List<EnumerationLiteral> enumerationLiterals;
				«FOR pkge : sortedPackages»

					ownedClasses = «pkge.getSymbolName()».getOwnedClasses();
					«FOR enumeration : ClassUtil.nullFree(pkge2enumerations.get(pkge))»
						ownedClasses.add(type = «enumeration.getSymbolName()»);
						enumerationLiterals = type.getOwnedLiterals();
						«FOR enumerationLiteral : enumeration.ownedLiterals»
							enumerationLiterals.add(«enumerationLiteral.getSymbolName()»);
						«ENDFOR»
						type.getSuperClasses().add(_OclEnumeration);
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineExternals(/*@NonNull*/ Model root) {
		var externals = root.getSortedExternals();
		if (externals.isEmpty()) return "";
		'''

			«FOR name : externals»«var element = ClassUtil.nonNullState(name2external.get(name))»
			«IF element instanceof Package»
			private final @NonNull Package «getPrefixedSymbolName(element, name)» = «element.getExternalReference()»;
			«ELSE»
			private final @NonNull «element.eClass().getName()» «getPrefixedSymbolName(element, name)» = «element.getExternalReference()»;
			«ENDIF»
			«ENDFOR»
		'''
	}

	protected def String defineIterations(/*@NonNull*/ Model root) {
		var pkge2iterations = root.getSortedIterations();
		if (pkge2iterations.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2iterations.keySet());
		var Class oldType  = null;
		'''

			«FOR pkge : sortedPackages»
				«FOR iteration : ClassUtil.nullFree(pkge2iterations.get(pkge))»
				private final @NonNull Iteration «iteration.getPrefixedSymbolName("it_" + iteration.partialName())» = createIteration("«iteration.
				name»", «iteration.type.getSymbolName()», «IF iteration.implementationClass !== null»"«iteration.
				implementationClass»", «iteration.implementationClass».INSTANCE«ELSE»null, null«ENDIF»«IF iteration.getOwnedSignature() !== null»«FOR templateParameter : iteration.getOwnedSignature().getOwnedParameters()», «templateParameter.getSymbolName()»«ENDFOR»«ENDIF»);
				«ENDFOR»
			«ENDFOR»

			private void installIterations() {
				List<Operation> ownedIterations;
				List<Parameter> ownedParameters;
				Iteration iteration;
				Parameter parameter;
				«FOR pkge : sortedPackages»
					«FOR iteration : ClassUtil.nullFree(pkge2iterations.get(pkge))»«var newType = iteration.getOwningClass()»
					«IF newType != oldType»

						ownedIterations = «(oldType = newType).getSymbolName()».getOwnedOperations();
					«ENDIF»
					ownedIterations.add(iteration = «iteration.getSymbolName()»);
					«IF iteration.isInvalidating»
						iteration.setIsInvalidating(true);
					«ENDIF»
					«IF !iteration.isRequired»
						iteration.setIsRequired(false);
					«ENDIF»
					«IF iteration.isStatic»
						iteration.setIsStatic(true);
					«ENDIF»
					«IF iteration.isTypeof»
						iteration.setIsTypeof(true);
					«ENDIF»
					«IF iteration.isValidating»
						iteration.setIsValidating(true);
					«ENDIF»
					«IF iteration.ownedIterators.size() > 0»
						ownedParameters = iteration.getOwnedIterators();
						«FOR parameter : iteration.ownedIterators»
							ownedParameters.add(parameter = createParameter("«parameter.name»", «parameter.type.getSymbolName()», «parameter.isRequired»));
							«IF parameter.isTypeof»
								parameter.setIsTypeof(true);
							«ENDIF»
						«ENDFOR»
					«ENDIF»
					«IF iteration.ownedAccumulators.size() > 0»
						ownedParameters = iteration.getOwnedAccumulators();
						«FOR parameter : iteration.ownedAccumulators»
							ownedParameters.add(parameter = createParameter("«parameter.name»", «parameter.type.getSymbolName()», «parameter.isRequired»));
							«IF parameter.isTypeof»
								parameter.setIsTypeof(true);
							«ENDIF»
						«ENDFOR»
					«ENDIF»
					«IF iteration.ownedParameters.size() > 0»
						ownedParameters = iteration.getOwnedParameters();
						«FOR parameter : iteration.ownedParameters»
							ownedParameters.add(parameter = createParameter("«parameter.name»", «parameter.type.getSymbolName()», «parameter.isRequired»));
							«IF parameter.isTypeof»
								parameter.setIsTypeof(true);
							«ENDIF»
						«ENDFOR»
					«ENDIF»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineLambdaTypes(/*@NonNull*/ Model root) {
		var allLambdaTypes = root.getSortedLambdaTypes();
		if (allLambdaTypes.isEmpty()) return "";
		var orphanPackage = root.getOrphanPackage();
		if (orphanPackage === null) return "";
		'''

			«FOR type : allLambdaTypes»
				private final @NonNull LambdaType «type.getPrefixedSymbolName("_" + type.partialName())» = createLambdaType("«type.
				name»");
			«ENDFOR»
			
			private void installLambdaTypes() {
				final List<Class> orphanTypes = «ClassUtil.nonNullState(orphanPackage).getSymbolName()».getOwnedClasses();
				LambdaType type;
				List<Class> superClasses;
				«FOR type : allLambdaTypes»
					orphanTypes.add(type = «type.getSymbolName()»);
					type.setContextType(«type.contextType.getSymbolName()»);
					«FOR parameterType : type.parameterType»
						type.getParameterType().add(«parameterType.getSymbolName()»);
					«ENDFOR»
					type.setResultType(«type.resultType.getSymbolName()»);
					«type.emitSuperClasses("type")»
				«ENDFOR»
			}
		'''
	}

	protected def String defineMapTypes(/*@NonNull*/ Model root) {
		var pkge2mapTypes = root.getSortedMapTypes();
		if (pkge2mapTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2mapTypes.keySet());
		'''

			private void installMapTypes() {
				List<Class> ownedClasses;
				List<Class> superClasses;
				MapType type;
				«FOR pkge : sortedPackages»

					ownedClasses = «pkge.getSymbolName()».getOwnedClasses();
					«FOR type : ClassUtil.nullFree(pkge2mapTypes.get(pkge))»
						ownedClasses.add(type = «type.getSymbolName()»);
						«type.emitSuperClasses("type")»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineOperations(/*@NonNull*/ Model root) {
		var pkge2operations = root.getSortedOperations();
		if (pkge2operations.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2operations.keySet());
		var Class oldType  = null;
		'''

			«FOR pkge : sortedPackages»
				«FOR operation : ClassUtil.nullFree(pkge2operations.get(pkge))»
				private final @NonNull Operation «operation.getPrefixedSymbolName("op_" + operation.partialName())» = createOperation(«operation.
				getNameLiteral()», «operation.type.getSymbolName()», «IF operation.implementationClass !== null»"«operation.
				implementationClass»", «operation.implementationClass».INSTANCE«ELSE»null, null«ENDIF»«IF operation.getOwnedSignature() !== null»«FOR templateParameter : operation.getOwnedSignature().getOwnedParameters()», «templateParameter.getSymbolName()»«ENDFOR»«ENDIF»);
				«ENDFOR»
			«ENDFOR»

			private void installOperations() {
				List<Operation> ownedOperations;
				List<Parameter> ownedParameters;
				Operation operation;
				Parameter parameter;
				«FOR pkge : sortedPackages»
					«FOR operation : ClassUtil.nullFree(pkge2operations.get(pkge))»«var newType = operation.getOwningClass()»
					«IF newType != oldType»

						ownedOperations = «(oldType = newType).getSymbolName()».getOwnedOperations();
					«ENDIF»
					ownedOperations.add(operation = «operation.getSymbolName()»);
					«IF operation.isInvalidating»
						operation.setIsInvalidating(true);
					«ENDIF»
					«IF !operation.isRequired»
						operation.setIsRequired(false);
					«ENDIF»
					«IF operation.isStatic»
						operation.setIsStatic(true);
					«ENDIF»
					«IF operation.isTypeof»
						operation.setIsTypeof(true);
					«ENDIF»
					«IF operation.isValidating»
						operation.setIsValidating(true);
					«ENDIF»
					«IF operation.bodyExpression !== null»
						createBodyExpression(operation, «operation.owningClass.getSymbolName()», "«operation.bodyExpression.javaString()»", «operation.type.getSymbolName()»);
					«ENDIF»
					«IF operation.ownedParameters.size() > 0»
						ownedParameters = operation.getOwnedParameters();
						«FOR parameter : operation.ownedParameters»
							ownedParameters.add(parameter = createParameter("«parameter.name»", «parameter.type.getSymbolName()», «parameter.isRequired»));
							«IF parameter.isTypeof»
								parameter.setIsTypeof(true);
							«ENDIF»
						«ENDFOR»
					«ENDIF»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String definePackages(/*@NonNull*/ Model root) {
		var allPackages = root.getSortedPackages();
		var import2alias = root.getSortedImports();
		var importKeys = new ArrayList<Package>(import2alias.keySet());
		Collections.sort(importKeys, nameableComparator);
		if (allPackages.isEmpty()) return "";
		'''

			private void installPackages() {
				«emitRoot(root)»
				«IF allPackages.size() > 0»
				«FOR pkg2 : allPackages»
				«emitPackage(pkg2)»
				«ENDFOR»
				«ENDIF»
			«FOR importKey : importKeys»«val importName = import2alias.get(importKey)»
				«root.getSymbolName()».getOwnedImports().add(createImport(«IF importName !== null»"«importName»"«ELSE»null«ENDIF», «importKey.getSymbolName()»));
			«ENDFOR»
			}
		'''
	}

	protected def String definePrecedences(Model root) {
		var allLibraries = root.getSortedLibrariesWithPrecedence();
		var allOperations = root.getSortedOperationsWithPrecedence();
		'''
			«IF (allLibraries.size() > 0) || (allOperations.size() > 0)»

				private void installPrecedences() {
					«IF allLibraries.size() > 0»
						List<Precedence> ownedPrecedences;

						«FOR lib : allLibraries»
						«var allPrecedences = lib.getSortedPrecedences()»
						«IF (allPrecedences !== null) && (allPrecedences.size() > 0)»
							«FOR precedence : allPrecedences»
								final Precedence «precedence.getPrefixedSymbolName("prec_" + precedence.partialName())» = createPrecedence("«precedence.name»", AssociativityKind.«precedence.associativity.toString().toUpperCase()»);
							«ENDFOR»

							ownedPrecedences = «lib.getSymbolName()».getOwnedPrecedences();
							«FOR precedence : lib.ownedPrecedences»
								ownedPrecedences.add(«precedence.getSymbolName()»);
							«ENDFOR»
						«ENDIF»
						«ENDFOR»
					«ENDIF»

					«FOR operation : allOperations»
						«operation.getSymbolName()».setPrecedence(«operation.precedence.getSymbolName()»);
					«ENDFOR»
				}
			«ENDIF»
		'''
	}

	protected def String definePrimitiveTypes(/*@NonNull*/ Model root) {
		var pkge2primitiveTypes = root.getSortedPrimitiveTypes();
		if (pkge2primitiveTypes.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2primitiveTypes.keySet());
		'''

			private void installPrimitiveTypes() {
				List<Class> ownedClasses;
				PrimitiveType type;
				«FOR pkge : sortedPackages»

					ownedClasses = «pkge.getSymbolName()».getOwnedClasses();
					«FOR type : ClassUtil.nullFree(pkge2primitiveTypes.get(pkge))»
						«var superClasses = type.getSuperclassesInPackage()»
						ownedClasses.add(type = «type.getSymbolNameWithoutNormalization()»);
						«FOR superClass : superClasses»
							type.getSuperClasses().add(«superClass.getSymbolName()»);
						«ENDFOR»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineProperties(/*@NonNull*/ Model root) {
		var pkge2properties = root.getSortedProperties();
		if (pkge2properties.isEmpty()) return "";
		var sortedPackages = root.getSortedPackages(pkge2properties.keySet());
		var Class oldType  = null;
		'''

			«FOR pkge : sortedPackages»

				«FOR property : ClassUtil.nullFree(pkge2properties.get(pkge))»
				private final @NonNull Property «property.getPrefixedSymbolName("pr_" + property.partialName())» = createProperty(«property.getNameLiteral()», «property.type.getSymbolName()»);
				«ENDFOR»
			«ENDFOR»

			private void installProperties() {
				List<Property> ownedProperties;
				Property property;
				«FOR pkge : sortedPackages»
					«FOR property : ClassUtil.nullFree(pkge2properties.get(pkge))»«var newType = property.getOwningClass()»
					«IF newType != oldType»

						ownedProperties = «(oldType = newType).getSymbolName()».getOwnedProperties();
					«ENDIF»
					ownedProperties.add(property = «property.getSymbolName()»);
					«IF property.isComposite»
						property.setIsComposite(true);
					«ENDIF»
					«IF property.isDerived»
						property.setIsDerived(true);
					«ENDIF»
					«IF property.isID»
						property.setIsID(true);
					«ENDIF»
					«IF property.isImplicit»
						property.setIsImplicit(true);
					«ENDIF»
					«IF property.isReadOnly»
						property.setIsReadOnly(true);
					«ENDIF»
					«IF !property.isRequired»
						property.setIsRequired(false);
					«ENDIF»
					«IF property.isResolveProxies»
						property.setIsResolveProxies(true);
					«ENDIF»
					«IF property.isStatic»
						property.setIsStatic(true);
					«ENDIF»
					«IF property.isTransient»
						property.setIsTransient(true);
					«ENDIF»
					«IF false /*property.isTypeof*/»
						property.setIsTypeof(true);
					«ENDIF»
					«IF property.isUnsettable»
						property.setIsUnsettable(true);
					«ENDIF»
					«IF property.isVolatile»
						property.setIsVolatile(true);
					«ENDIF»
					«IF property.defaultValueString !== null»
						property.setDefaultValueString("«property.defaultValueString»");
					«ENDIF»
					«IF property.opposite !== null»
						property.setOpposite(«property.opposite.getSymbolName()»);
					«ENDIF»
					«IF property.implementationClass !== null»
						property.setImplementationClass("«property.implementationClass»");
						property.setImplementation(«property.implementationClass».INSTANCE);
					«ENDIF»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineTemplateBindings(/*@NonNull*/ Model root) {
		var allTemplateableElements = root.getSortedTemplateableElements(symbolNameComparator);
		if (allTemplateableElements.isEmpty()) return "";
		'''

			private void installTemplateBindings() {
				«FOR templateableElement : allTemplateableElements»
					«FOR templateBinding : templateableElement.ownedBindings»
						«FOR templateParameterSubstitution : templateBinding.ownedSubstitutions»
							addBinding(«templateableElement.getSymbolName()», «templateParameterSubstitution.actual.getSymbolName()»);
						«ENDFOR»
					«ENDFOR»
				«ENDFOR»
			}
		'''
	}

	protected def String defineTemplateParameters(/*@NonNull*/ Model root) {
		var allTemplateParameters = root.getSortedTemplateParameters();
		if (allTemplateParameters.isEmpty()) return "";
		'''

			«FOR templateParameter : allTemplateParameters»
			private final @NonNull TemplateParameter «templateParameter.getPrefixedSymbolName(
						"tp_" + templateParameter.partialName())» = createTemplateParameter("«templateParameter.getName()»");
			«ENDFOR»
		'''
	}

	protected def String defineTupleTypes(/*@NonNull*/ Model root) {
		var allTupleTypes = root.getSortedTupleTypes();
		if (allTupleTypes.isEmpty()) return "";
		var orphanPackage = root.getOrphanPackage();
		if (orphanPackage === null) return "";
		'''

			private void installTupleTypes() {
				final List<Class> orphanTypes = «ClassUtil.nonNullState(orphanPackage).getSymbolName()».getOwnedClasses();
				TupleType type;
				List<Class> superClasses;
				«FOR type : allTupleTypes»
					orphanTypes.add(type = «type.getSymbolName()»);
					«FOR property : type.getSortedProperties()»
						«IF property.implementationClass !== null»
							«property.getSymbolName()».setImplementationClass("«property.implementationClass»");
							«property.getSymbolName()».setImplementation(«property.implementationClass».INSTANCE);
						«ENDIF»
					«ENDFOR»
					«type.emitSuperClasses("type")»
				«ENDFOR»
			}
		'''
	}

	protected def String emitCreateProperty(Property property) {
		return "createProperty(" + property.name + ", " + property.type.getSymbolName() + ")";
	}

	protected def String emitPackage(Package pkg) {
		'''
			«FOR nestedPackage : pkg.getSortedPackages()»
				«IF nestedPackage.getOwnedPackages().size() > 0»
					«emitPackage(nestedPackage)»
				«ENDIF»
				«pkg.getSymbolName()».getOwnedPackages().add(«nestedPackage.getSymbolName()»);
			«ENDFOR»
		'''
	}

	protected def String emitRoot(Model pkg) {
		'''
			«FOR nestedPackage : pkg.getSortedPackages()»
				«IF nestedPackage.getOwnedPackages().size() > 0»
					«emitPackage(nestedPackage)»
				«ENDIF»
				«pkg.getSymbolName()».getOwnedPackages().add(«nestedPackage.getSymbolName()»);
			«ENDFOR»
		'''
	}

	protected def String emitSuperClasses(Class type, String typeName) {
		var superClasses = type.getSuperclassesInPackage();
		'''
			«IF superClasses.size() > 0»
				superClasses = «typeName».getSuperClasses();
				«FOR superClass : superClasses»
					superClasses.add(«superClass.getSymbolName()»);
				«ENDFOR»
			«ELSEIF (type instanceof MapType)»
				superClasses = «typeName».getSuperClasses();
				superClasses.add(_OclAny);
			«ELSEIF (type instanceof AnyType)»
			«ELSEIF "OclElement".equals(type.getName())»
			«ELSE»
				superClasses = «typeName».getSuperClasses();
				superClasses.add(_OclElement);
			«ENDIF»
		'''
	}

	protected def String installCoercions(/*@NonNull*/ Model root) {
		var allCoercions = root.getSortedCoercions();
		if (allCoercions.isEmpty()) return "";
		'''installCoercions();'''
	}

	protected def String installClassTypes(/*@NonNull*/ Model root) {
		var pkge2classTypes = root.getSortedClassTypes();
		if (pkge2classTypes.isEmpty()) return "";
		'''installClassTypes();'''
	}

	protected def String installCollectionTypes(/*@NonNull*/ Model root) {
		var pkge2collectionTypes = root.getSortedCollectionTypes();
		if (pkge2collectionTypes.isEmpty()) return "";
		'''installCollectionTypes();'''
	}

	protected def String installComments(/*@NonNull*/ Model root) {
		'''installComments();'''
	}

	protected def String installEnumerations(/*@NonNull*/ Model root) {
		var pkge2enumerations = root.getSortedEnumerations();
		if (pkge2enumerations.isEmpty()) return "";
		'''installEnumerations();'''
	}

	protected def String installIterations(/*@NonNull*/ Model root) {
		var pkge2iterations = root.getSortedIterations();
		if (pkge2iterations.isEmpty()) return "";
		'''installIterations();'''
	}

	protected def String installLambdaTypes(/*@NonNull*/ Model root) {
		var allLambdaTypes = root.getSortedLambdaTypes();
		if (allLambdaTypes.isEmpty()) return "";
		'''installLambdaTypes();'''
	}

	protected def String installMapTypes(/*@NonNull*/ Model root) {
		var pkge2mapTypes = root.getSortedMapTypes();
		if (pkge2mapTypes.isEmpty()) return "";
		'''installMapTypes();'''
	}

	protected def String installOperations(/*@NonNull*/ Model root) {
		var pkge2operations = root.getSortedOperations();
		if (pkge2operations.isEmpty()) return "";
		'''installOperations();'''
	}

	protected def String installPackages(/*@NonNull*/ Model root) {
		var allPackages = root.getSortedPackages();
		if (allPackages.isEmpty()) return "";
		'''installPackages();'''
	}

	protected def String installPrecedences(/*@NonNull*/ Model root) {
		var allLibraries = root.getSortedLibrariesWithPrecedence();
		var allOperations = root.getSortedOperationsWithPrecedence();
		if (allLibraries.isEmpty() && allOperations.isEmpty()) return "";
		'''installPrecedences();'''
	}

	protected def String installPrimitiveTypes(/*@NonNull*/ Model root) {
		var pkge2primitiveTypes = root.getSortedPrimitiveTypes();
		if (pkge2primitiveTypes.isEmpty()) return "";
		'''installPrimitiveTypes();'''
	}

	protected def String installProperties(/*@NonNull*/ Model root) {
		var pkge2properties = root.getSortedProperties();
		if (pkge2properties.isEmpty()) return "";
		'''installProperties();'''
	}
	
	protected def String installTemplateBindings(/*@NonNull*/ Model root) {
		var allTemplateableElements = root.getSortedTemplateableElements(null);
		if (allTemplateableElements.isEmpty()) return "";
		'''installTemplateBindings();'''
	}

	protected def String installTupleTypes(/*@NonNull*/ Model root) {
		var allTupleTypes = root.getSortedTupleTypes();
		if (allTupleTypes.size() <= 0) return "";
		'''installTupleTypes();'''
	}

	/**
	 * Generate a name for element suitable for embedding in a surrounding punctuation context.
	 */
	protected override String partialName(EObject element) {
		switch element {
			CollectionType case element.elementType === null: return element.javaName()
			CollectionType: return element.javaName()
			LambdaType case element.contextType === null: return "null"
			LambdaType: return element.javaName() + "_" + element.contextType.partialName()
			MapType case element.keyType === null: return element.javaName()
			MapType case element.valueType === null: return element.javaName()
			MapType: return element.javaName()
			Class case element.ownedBindings.size() > 0: return '''«element.javaName()»«FOR TemplateParameterSubstitution tps : element.getTemplateParameterSubstitutions()»_«tps.actual.simpleName()»«ENDFOR»'''
			Class: return element.javaName()
			Comment case element.body === null: return "null"
			Comment: return element.javaName(element.body.substring(0, Math.min(11, element.body.length() - 1)))
			EnumerationLiteral case element.owningEnumeration === null: return "null"
			EnumerationLiteral: return element.owningEnumeration.partialName() + "_" + element.javaName()
			Operation case element.owningClass === null: return "null_" + element.javaName()
			Operation: return element.owningClass.partialName() + "_" + element.javaName()
			Package: return element.javaName()
			Parameter case element.eContainer() === null: return "null_" + element.javaName()
			Parameter: return element.eContainer().partialName() + "_" + element.javaName()
			Precedence: return element.javaName()
			Property: return getPartialName(element)
			TemplateBinding case element.getTemplateSignature().owningElement === null: return "null"
			TemplateBinding: return element.owningElement.partialName()
			TemplateParameter case element.getOwningSignature.owningElement === null: return "[" + element.getOwningSignature.partialName() + "]"
//			TemplateParameter case element.getOwningTemplateSignature.owningTemplateableElement.getUnspecializedElement() == null: return element.javaName()
			TemplateParameter: return element.getOwningSignature.owningElement.partialName() + "_" + element.javaName()
			TemplateParameterSubstitution case element.owningBinding === null: return "null"
			TemplateParameterSubstitution case element.owningBinding.owningElement === null: return "null"
			TemplateParameterSubstitution: return element.owningBinding.owningElement.partialName()
			TemplateSignature case element.owningElement === null: return "null"
			TemplateSignature: return element.owningElement.partialName()
			default: return "xyzzy" + element.eClass().name
		}		
	}

	protected def String simpleName(EObject element) {
		switch element {
			TemplateParameter case element.getOwningSignature.owningElement === null: return "null"
			TemplateParameter: return element.getOwningSignature.owningElement.simpleName() + "_" + element.javaName()
			TemplateParameterSubstitution case element.owningBinding === null: return "null"
			TemplateParameterSubstitution case element.owningBinding.owningElement === null: return "null"
			TemplateParameterSubstitution: return element.owningBinding.owningElement.simpleName()
			Class: return element.javaName()
			Operation case element.owningClass === null: return "null_" + element.javaName()
			Operation: return element.owningClass.simpleName() + "_" + element.javaName()
			default: return "xyzzy" + element.eClass().name
		}		
	}
}