org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/lifting/ArrayTranslations.java - objectteams/org.eclipse.objectteams - Gitiles

 /**********************************************************************
  * This file is part of "Object Teams Development Tooling"-Software
  *
  * Copyright 2004, 2012 Fraunhofer Gesellschaft, Munich, Germany,
  * for its Fraunhofer Institute for Computer Architecture and Software
  * Technology (FIRST), Berlin, Germany and Technical University Berlin,
  * Germany.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  * $Id: ArrayTranslations.java 23416 2010-02-03 19:59:31Z stephan $
  *
  * Please visit http://www.eclipse.org/objectteams for updates and contact.
  *
  * Contributors:
  * Fraunhofer FIRST - Initial API and implementation
  * Technical University Berlin - Initial API and implementation
  **********************************************************************/
 package org.eclipse.objectteams.otdt.internal.core.compiler.lifting;

 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ast.*;
 import org.eclipse.jdt.internal.compiler.ast.Expression.DecapsulationState;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.impl.Constant;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
 import org.eclipse.objectteams.otdt.core.exceptions.InternalCompilerError;
 import org.eclipse.objectteams.otdt.internal.core.compiler.model.TeamModel;
 import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstConverter;
 import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstEdit;
 import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstGenerator;

 /**
  * This class handles the common part of array lifting and lowering.
  *
  * @author stephan
  * @version $Id: ArrayTranslations.java 23416 2010-02-03 19:59:31Z stephan $
  */
 public abstract class ArrayTranslations {

 	private static final char[] ROLE_ARRAY_ARG = "_OT$roleArray".toCharArray(); //$NON-NLS-1$
 	BlockScope _scope;
 	TypeBinding _providedType;
 	TypeBinding _requiredType;
 	Expression _teamExpr;
 	Expression _expression;
 	boolean     _isLifting;

 	/**
 	 * This method handles lowering of arrays of roles by generating an
 	 * extra method that returns the lowered array.
 	 *
 	 * The following example shows code that will be generated
 	 * for a threedimensional Role-type array:
 	 *
 	 * void myCallout(Role[][][] r)
 	 * {
 	 *   __OT$base.myBaseMethod(transformArray(r));
 	 * }
 	 *
 	 * Base[][][] transformArray(Role[][][] role)
 	 * {
 	 *   Base[][][] result;
 	 *
 	 *   result = new Base[role.length][][];
 	 *   for(;i0 < role.length;i0++){
 	 * 	    result[i0] = new Base[role[i0].length][];
 	 * 	    for(i1 < role[i0].length;){
 	 *   		result[i0][i1] = new Base[role[i0][i1].length];
 	 * 	     	for(i2 < role[i0][i1].length;){
 	 * 	    		result[i0][i1][i2] = translate(role[i0][i1][i2]);
 	 * 			}
 	 * 	 	}
 	 * 	 }
 	 *   return result;
 	 * }
 	 * @param scope
 	 * @param expression wrap this expression with the desired translation
 	 * @param providedType given type of expression
 	 * @param requiredType this should be produced by translation
 	 * @param isLifting is a lifting translation required (else == lowering)
 	 * @return a message send to the appropriate translation method.
 	 */
 	Expression translateArray(BlockScope  scope, Expression  expression, TypeBinding providedType, TypeBinding requiredType, boolean     isLifting) {
 		this._scope      = scope;
 		this._expression = expression;

 		MethodBinding methodBinding = ensureTransformMethod(
 										scope, this._teamExpr, providedType, requiredType, isLifting);

 		AstGenerator gen = new AstGenerator(expression.sourceStart, expression.sourceEnd);
 		MessageSend send = gen.messageSend(
 				this._teamExpr,
 				methodBinding.selector,
 				new Expression[] {expression});

 		// manual resolving since expression is already resolved:
         send.binding = methodBinding;
 	    send.actualReceiverType = expression.resolvedType;
 	    send.resolvedType   = methodBinding.returnType;
 	    send.constant = Constant.NotAConstant;
 	    return send;
 	}

 	public MethodBinding ensureTransformMethod(
 							BlockScope  scope,
 							Expression  teamExpr,
 							TypeBinding providedType,
 							TypeBinding requiredType,
 							boolean     isLifting)
 	{
 		this._providedType = providedType;
 		this._requiredType = requiredType;
 		this._isLifting    = isLifting;
 		this._teamExpr     = teamExpr;
 		this._scope        = scope;

 		ReferenceBinding roleType = isLifting ?
 				  ((ReferenceBinding)requiredType.leafComponentType())
 				: ((ReferenceBinding)providedType.leafComponentType());

 		char[] transformMethodName = getTransformMethodName(roleType, providedType.dimensions(), isLifting);

 	    ReferenceBinding enclosingTeam = roleType.enclosingType().getRealType();
 		MethodBinding[] transformMethods = enclosingTeam.getMethods(transformMethodName);
 	    MethodBinding methodBinding = null;
 	    if ((transformMethods != null) && (transformMethods.length != 0)) {
 	        if (transformMethods.length > 1) {
 	            throw new InternalCompilerError("duplicate transform methods generated");                //$NON-NLS-1$
 	        }
 	        methodBinding = transformMethods[0];
 	    } else {
 	    	TeamModel teamModel = roleType.roleModel.getTeamModel();
 			TypeDeclaration teamDecl = teamModel.getAst();
 	    	if (teamDecl == null)
 				throw new InternalCompilerError(
 						"need to create transform method, but have no source type: "+new String(teamModel.getBinding().readableName())); //$NON-NLS-1$

 	        MethodDeclaration transformMethod =
 	                generateTransformArrayMethod(teamDecl, transformMethodName, providedType.dimensions());
 	        if (teamDecl.isRole())
 	        	transformMethod.modifiers |= ClassFileConstants.AccPublic;
 	        AstEdit.addMethod(teamDecl, transformMethod);
 	        methodBinding = transformMethod.binding;
 	        if (teamDecl.isRole()) {
 	        	// if team is a role, also generate a ifc-part for the method and use that
 	        	TypeDeclaration ifcPart = teamDecl.getRoleModel().getInterfaceAst();
 	        	MethodDeclaration ifcMethod = AstConverter.genRoleIfcMethod(ifcPart, transformMethod);
 	        	AstEdit.addMethod(ifcPart, ifcMethod);
 	        	methodBinding = ifcMethod.binding;
 	        }
 	    }
 		return methodBinding;
 	}

 	public static char[] getTransformMethodName(ReferenceBinding roleType, int dimensions, boolean isLifting) {
 		return
 			CharOperation.concat(
 	                CharOperation.concat(
 	                    isLifting ? IOTConstants._OT_LIFT_TO : IOTConstants.OT_TRANSFORM_ARRAY,
 	                    roleType.sourceName()),
 	                CharOperation.concat(
 	                    IOTConstants.OT_DOLLAR_NAME,
 	                    (""+dimensions).toCharArray())); //$NON-NLS-1$
 	}
 	// === the following methods mark ast nodes as allowing baseclass decapsulation ===
 	// for lifting the input side allows decapsulation, for lowering its the output side.
 	/** Mark nameRef for baseclass decapsulation, if input is the base side. */
 	private NameReference decapsulationInput(NameReference nameRef) {
 		if (this._isLifting)
 			nameRef.baseclassDecapsulation = DecapsulationState.REPORTED;
 		return nameRef;
 	}
 	/** Mark nameRef for baseclass decapsulation, if output is the base side. */
 	private NameReference decapsulationOutput(NameReference nameRef) {
 		if (!this._isLifting)
 			nameRef.baseclassDecapsulation = DecapsulationState.REPORTED;
 		return nameRef;
 	}
 	/** Mark typeRef for baseclass decapsulation, if input is the base side. */
 	private void decapsulationInput(TypeReference typeRef) {
 		if (this._isLifting)
 			typeRef.setBaseclassDecapsulation(DecapsulationState.REPORTED);
 	}
 	/** Mark typeRef for baseclass decapsulation, if output is the base side. */
 	private void decapsulationOutput(TypeReference typeRef) {
 		if (!this._isLifting)
 			typeRef.setBaseclassDecapsulation(DecapsulationState.REPORTED);
 	}

 	/**
 	 * generate code for prevent null-pointer exceptions
 	 * if(r1 == null)return null;
 	 * if(r1[i0][i1] == null)continue;
 	 * @param currentDimension
 	 * @param arrayDimensions
 	 * @return an if statement
 	 */
 	private IfStatement generateIfStatement(int currentDimension, int arrayDimensions) {

 		SingleNameReference condLeft = new SingleNameReference(ROLE_ARRAY_ARG,0);
 		decapsulationInput(condLeft);

 		Expression lastArrayReference = condLeft;

 		for (int idx = 0; idx < currentDimension; idx++) {
 			SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
 			ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
 			lastArrayReference = nextArray;
 		}

  		Expression condRight = new NullLiteral(0,0);
 		Expression condition = new EqualExpression(lastArrayReference,condRight,OperatorIds.EQUAL_EQUAL);

 		Statement thenStatement=null;
 		if(currentDimension == 0)
 		{
 			thenStatement = new ReturnStatement(new NullLiteral(0,0), 0, 0);
 		}
 		else
 		{
 			thenStatement = new ContinueStatement(null,0,0);
 		}
 		IfStatement ifStatement = new IfStatement(condition,thenStatement,0,0);
 		return ifStatement;
 	}

 	/**
 	 * generates an array index name . e.g. "i0","i1"...
 	 * @param dimension
 	 * @return the name
 	 */
 	private static char[] generateArrayIndexName(int dimension)
 	{
 		return new String(IOTConstants.OT_DOLLAR).concat("i".concat(String.valueOf(dimension))).toCharArray();	 //$NON-NLS-1$
 	}
 	/**
 	 * 	for(int i0=0;i0 < role.length;i0++)
 	 *	{
 	 *		result = new Base[role.length][][];
 	 *		for(...){
 	 *			...
 	 *				for(int i2=0;i2 < role[i0][i1].length;i2++){
 	 * 		    		result[i0][i1][i2] = translate(role[i0][i1][i2]);
 	 * 				}
 	 * 			...
 	 * 		}
 	 *	}
 	 * @param currentDimension counter for recursion only. invoke initially with 0.
 	 * @param arrayDimensions maximum of dimensions of the array
 	 * @return the new created ForStatement with all subcycles
 	 */
 	private ForStatement generateForStatement(int currentDimension, int arrayDimensions, AstGenerator gen)
 	{

 		Statement[] init = new Statement[1];
 		char[] name = generateArrayIndexName(currentDimension);

 		LocalDeclaration initializer = new LocalDeclaration(name,0,0);
 		initializer.initialization = IntLiteral.buildIntLiteral("0".toCharArray(),0,0); //$NON-NLS-1$
 		initializer.type = new SingleTypeReference(TypeConstants.INT, 0);
 		init[0] = initializer;

 		SingleNameReference condLeft = new SingleNameReference(name,0);

 		FieldReference  condRight = new FieldReference(IOTConstants.LENGTH,0);
 		SingleNameReference roleNameReference = gen.singleNameReference(ROLE_ARRAY_ARG);
 		decapsulationInput(roleNameReference);

 		Expression lastArrayReference = roleNameReference;

 		for (int idx = 0; idx < currentDimension; idx++) {
 			SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
 			ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
 			lastArrayReference = nextArray;
 		}
 		condRight.receiver =  lastArrayReference;

 		Expression 	cond = new BinaryExpression(condLeft,condRight,OperatorIds.LESS);
 		Statement[] inc = new Statement[1];

 		inc[0]= new PostfixExpression(new SingleNameReference(name,0),IntLiteral.One,OperatorIds.PLUS,0);

 		Block action = new Block(0);

 		// result = new Base[role.length][][];
 		Assignment arrayInstantiation =
 			generateArrayInstantiation(currentDimension+1, arrayDimensions, gen);

 		// if(r1 == null)continue;
 		IfStatement ifStatement =
 			generateIfStatement(currentDimension+1, arrayDimensions);

 		if(currentDimension<arrayDimensions-1)
 		{
 			ForStatement innerForStatement = generateForStatement(currentDimension + 1, arrayDimensions, gen);
 			action.statements = new Statement[3];
 			action.statements[0] = ifStatement;
 			action.statements[1] = arrayInstantiation;
 			action.statements[2] = innerForStatement;
 		}
 		else
 		{
 			action.statements = new Statement[2];
 			action.statements[0] = ifStatement;
 			action.statements[1] = arrayInstantiation;
 		}

 		// for(;i0 < role.length;i0++)
 		ForStatement outerForStatement = new ForStatement(init,cond, inc, action, true,0,0);

 		return outerForStatement;
 	}
 	/**
 	 * creates AST-Element
 	 *
 	 * if currentDimension == 1 -> result = new Base[role.length][][];
 	 * if currentDimension == 2 -> result[i0] =  new Base[role[i0].length][][];
 	 * if currentDimension == arrayDimensions -> result[i0][i1][i2] = role[i0][i1][i2]._OT$Base;
 	 * @param currentDimension some dimensions must have special treatment
 	 * @param arrayDimensions maximum of dimensions of the array
 	 * @return the new created assignment
 	 */
 	private Assignment generateArrayInstantiation(int currentDimension, int arrayDimensions, AstGenerator gen)
 	{

 		SingleNameReference resultNameReference = new SingleNameReference(IOTConstants.OT_RESULT,0);
 		decapsulationOutput(resultNameReference);

 		Expression lastArrayReference = resultNameReference;

 		for (int idx = 0; idx < currentDimension; idx++) {
 			SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
 			ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
 			lastArrayReference = nextArray;
 		}
 		Expression lhsReference = lastArrayReference;

 		lastArrayReference = decapsulationInput(gen.singleNameReference(ROLE_ARRAY_ARG));

 		for (int idx = 0; idx < currentDimension; idx++) {
 			SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
 			ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
 			lastArrayReference = nextArray;
 		}
 		Expression rhsReference = lastArrayReference;

 		if(currentDimension == arrayDimensions)
 		{
 			return new Assignment(
 					lhsReference,
 					translation(rhsReference, this._providedType.leafComponentType(), this._requiredType.leafComponentType()),
 					0);
 		}
 		else
 		{
 			//new Required[role[i0].length][][];
 			FieldReference lengthFieldReference = new FieldReference(IOTConstants.LENGTH,0);
 			lengthFieldReference.receiver = rhsReference;


 			TypeReference reqTypeReference = gen.typeReference(this._requiredType.leafComponentType());
 			decapsulationOutput(reqTypeReference);

 			ArrayAllocationExpression reqAllocationExpression = new ArrayAllocationExpression();
 			reqAllocationExpression.type = reqTypeReference;
 			reqAllocationExpression.dimensions = new Expression[arrayDimensions-currentDimension];
 			reqAllocationExpression.dimensions[0] = lengthFieldReference;

 			Assignment assignment = new Assignment(lhsReference,reqAllocationExpression,0);
 			return assignment;
 		}
 	}

 	/**
 	 * Hook method to fill in the atomic translation of one object.
 	 * @param rhs
 	 * @param providedType
 	 * @param requiredType
 	 * @return expression translating a single object
 	 */
 	abstract Expression translation(Expression rhs, TypeBinding providedType, TypeBinding requiredType);
 	private MethodDeclaration generateTransformArrayMethod(
 				TypeDeclaration teamType,
 				char[] transformMethodName,
 				int arrayDimensions)
 	{
 		AstGenerator gen = new AstGenerator(teamType.sourceStart, teamType.sourceEnd);

 		MethodDeclaration transformArrayMethod = gen.method(
 								teamType.compilationResult(),
 								0, // modifiers
 								this._requiredType,
 								transformMethodName,
 								new Argument[] {
 										gen.argument(
 						                    ROLE_ARRAY_ARG,
 						                    gen.typeReference(this._providedType))
 								});
 		decapsulationInput(transformArrayMethod.arguments[0].type);
 		decapsulationOutput(transformArrayMethod.returnType);

         // if(r1 == null)return null;
         IfStatement ifStatement =
             generateIfStatement(0, arrayDimensions);

         //  Base[][][] result = null;
         LocalDeclaration reqArrayDeclaration =
             gen.localVariable(IOTConstants.OT_RESULT, this._requiredType, gen.nullLiteral());
         decapsulationOutput(reqArrayDeclaration.type);

         //  result = new Base[role.length][][];
         Assignment arrayInstantiation =
             generateArrayInstantiation(0,arrayDimensions, gen);

         // for(...){...}
         ForStatement forStatement =
             generateForStatement(0,arrayDimensions, gen);

         // return result;
         ReturnStatement returnStatement =
             gen.returnStatement(gen.singleNameReference(IOTConstants.OT_RESULT));


         transformArrayMethod.setStatements(new Statement[] {
         		ifStatement,
         		reqArrayDeclaration,
         		arrayInstantiation,
         		forStatement,
         		returnStatement});

 		return  transformArrayMethod;
 	}
 }
	/**********************************************************************
	* This file is part of "Object Teams Development Tooling"-Software
	*
	* Copyright 2004, 2012 Fraunhofer Gesellschaft, Munich, Germany,
	* for its Fraunhofer Institute for Computer Architecture and Software
	* Technology (FIRST), Berlin, Germany and Technical University Berlin,
	* Germany.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	* $Id: ArrayTranslations.java 23416 2010-02-03 19:59:31Z stephan $
	*
	* Please visit http://www.eclipse.org/objectteams for updates and contact.
	*
	* Contributors:
	* Fraunhofer FIRST - Initial API and implementation
	* Technical University Berlin - Initial API and implementation
	**********************************************************************/
	package org.eclipse.objectteams.otdt.internal.core.compiler.lifting;

	import org.eclipse.jdt.core.compiler.CharOperation;
	import org.eclipse.jdt.internal.compiler.ast.*;
	import org.eclipse.jdt.internal.compiler.ast.Expression.DecapsulationState;
	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
	import org.eclipse.jdt.internal.compiler.impl.Constant;
	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
	import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
	import org.eclipse.objectteams.otdt.core.exceptions.InternalCompilerError;
	import org.eclipse.objectteams.otdt.internal.core.compiler.model.TeamModel;
	import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstConverter;
	import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstEdit;
	import org.eclipse.objectteams.otdt.internal.core.compiler.util.AstGenerator;

	/**
	* This class handles the common part of array lifting and lowering.
	*
	* @author stephan
	* @version $Id: ArrayTranslations.java 23416 2010-02-03 19:59:31Z stephan $
	*/
	public abstract class ArrayTranslations {

	private static final char[] ROLE_ARRAY_ARG = "_OT$roleArray".toCharArray(); //$NON-NLS-1$
	BlockScope _scope;
	TypeBinding _providedType;
	TypeBinding _requiredType;
	Expression _teamExpr;
	Expression _expression;
	boolean _isLifting;

	/**
	* This method handles lowering of arrays of roles by generating an
	* extra method that returns the lowered array.
	*
	* The following example shows code that will be generated
	* for a threedimensional Role-type array:
	*
	* void myCallout(Role[][][] r)
	* {
	* __OT$base.myBaseMethod(transformArray(r));
	* }
	*
	* Base[][][] transformArray(Role[][][] role)
	* {
	* Base[][][] result;
	*
	* result = new Base[role.length][][];
	* for(;i0 < role.length;i0++){
	* result[i0] = new Base[role[i0].length][];
	* for(i1 < role[i0].length;){
	* result[i0][i1] = new Base[role[i0][i1].length];
	* for(i2 < role[i0][i1].length;){
	* result[i0][i1][i2] = translate(role[i0][i1][i2]);
	* }
	* }
	* }
	* return result;
	* }
	* @param scope
	* @param expression wrap this expression with the desired translation
	* @param providedType given type of expression
	* @param requiredType this should be produced by translation
	* @param isLifting is a lifting translation required (else == lowering)
	* @return a message send to the appropriate translation method.
	*/
	Expression translateArray(BlockScope scope, Expression expression, TypeBinding providedType, TypeBinding requiredType, boolean isLifting) {
	this._scope = scope;
	this._expression = expression;

	MethodBinding methodBinding = ensureTransformMethod(
	scope, this._teamExpr, providedType, requiredType, isLifting);

	AstGenerator gen = new AstGenerator(expression.sourceStart, expression.sourceEnd);
	MessageSend send = gen.messageSend(
	this._teamExpr,
	methodBinding.selector,
	new Expression[] {expression});

	// manual resolving since expression is already resolved:
	send.binding = methodBinding;
	send.actualReceiverType = expression.resolvedType;
	send.resolvedType = methodBinding.returnType;
	send.constant = Constant.NotAConstant;
	return send;
	}

	public MethodBinding ensureTransformMethod(
	BlockScope scope,
	Expression teamExpr,
	TypeBinding providedType,
	TypeBinding requiredType,
	boolean isLifting)
	{
	this._providedType = providedType;
	this._requiredType = requiredType;
	this._isLifting = isLifting;
	this._teamExpr = teamExpr;
	this._scope = scope;

	ReferenceBinding roleType = isLifting ?
	((ReferenceBinding)requiredType.leafComponentType())
	: ((ReferenceBinding)providedType.leafComponentType());

	char[] transformMethodName = getTransformMethodName(roleType, providedType.dimensions(), isLifting);

	ReferenceBinding enclosingTeam = roleType.enclosingType().getRealType();
	MethodBinding[] transformMethods = enclosingTeam.getMethods(transformMethodName);
	MethodBinding methodBinding = null;
	if ((transformMethods != null) && (transformMethods.length != 0)) {
	if (transformMethods.length > 1) {
	throw new InternalCompilerError("duplicate transform methods generated"); //$NON-NLS-1$
	}
	methodBinding = transformMethods[0];
	} else {
	TeamModel teamModel = roleType.roleModel.getTeamModel();
	TypeDeclaration teamDecl = teamModel.getAst();
	if (teamDecl == null)
	throw new InternalCompilerError(
	"need to create transform method, but have no source type: "+new String(teamModel.getBinding().readableName())); //$NON-NLS-1$

	MethodDeclaration transformMethod =
	generateTransformArrayMethod(teamDecl, transformMethodName, providedType.dimensions());
	if (teamDecl.isRole())
	transformMethod.modifiers \|= ClassFileConstants.AccPublic;
	AstEdit.addMethod(teamDecl, transformMethod);
	methodBinding = transformMethod.binding;
	if (teamDecl.isRole()) {
	// if team is a role, also generate a ifc-part for the method and use that
	TypeDeclaration ifcPart = teamDecl.getRoleModel().getInterfaceAst();
	MethodDeclaration ifcMethod = AstConverter.genRoleIfcMethod(ifcPart, transformMethod);
	AstEdit.addMethod(ifcPart, ifcMethod);
	methodBinding = ifcMethod.binding;
	}
	}
	return methodBinding;
	}

	public static char[] getTransformMethodName(ReferenceBinding roleType, int dimensions, boolean isLifting) {
	return
	CharOperation.concat(
	CharOperation.concat(
	isLifting ? IOTConstants._OT_LIFT_TO : IOTConstants.OT_TRANSFORM_ARRAY,
	roleType.sourceName()),
	CharOperation.concat(
	IOTConstants.OT_DOLLAR_NAME,
	(""+dimensions).toCharArray())); //$NON-NLS-1$
	}
	// === the following methods mark ast nodes as allowing baseclass decapsulation ===
	// for lifting the input side allows decapsulation, for lowering its the output side.
	/** Mark nameRef for baseclass decapsulation, if input is the base side. */
	private NameReference decapsulationInput(NameReference nameRef) {
	if (this._isLifting)
	nameRef.baseclassDecapsulation = DecapsulationState.REPORTED;
	return nameRef;
	}
	/** Mark nameRef for baseclass decapsulation, if output is the base side. */
	private NameReference decapsulationOutput(NameReference nameRef) {
	if (!this._isLifting)
	nameRef.baseclassDecapsulation = DecapsulationState.REPORTED;
	return nameRef;
	}
	/** Mark typeRef for baseclass decapsulation, if input is the base side. */
	private void decapsulationInput(TypeReference typeRef) {
	if (this._isLifting)
	typeRef.setBaseclassDecapsulation(DecapsulationState.REPORTED);
	}
	/** Mark typeRef for baseclass decapsulation, if output is the base side. */
	private void decapsulationOutput(TypeReference typeRef) {
	if (!this._isLifting)
	typeRef.setBaseclassDecapsulation(DecapsulationState.REPORTED);
	}

	/**
	* generate code for prevent null-pointer exceptions
	* if(r1 == null)return null;
	* if(r1[i0][i1] == null)continue;
	* @param currentDimension
	* @param arrayDimensions
	* @return an if statement
	*/
	private IfStatement generateIfStatement(int currentDimension, int arrayDimensions) {

	SingleNameReference condLeft = new SingleNameReference(ROLE_ARRAY_ARG,0);
	decapsulationInput(condLeft);

	Expression lastArrayReference = condLeft;

	for (int idx = 0; idx < currentDimension; idx++) {
	SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
	ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
	lastArrayReference = nextArray;
	}

	Expression condRight = new NullLiteral(0,0);
	Expression condition = new EqualExpression(lastArrayReference,condRight,OperatorIds.EQUAL_EQUAL);

	Statement thenStatement=null;
	if(currentDimension == 0)
	{
	thenStatement = new ReturnStatement(new NullLiteral(0,0), 0, 0);
	}
	else
	{
	thenStatement = new ContinueStatement(null,0,0);
	}
	IfStatement ifStatement = new IfStatement(condition,thenStatement,0,0);
	return ifStatement;
	}

	/**
	* generates an array index name . e.g. "i0","i1"...
	* @param dimension
	* @return the name
	*/
	private static char[] generateArrayIndexName(int dimension)
	{
	return new String(IOTConstants.OT_DOLLAR).concat("i".concat(String.valueOf(dimension))).toCharArray(); //$NON-NLS-1$
	}
	/**
	* for(int i0=0;i0 < role.length;i0++)
	* {
	* result = new Base[role.length][][];
	* for(...){
	* ...
	* for(int i2=0;i2 < role[i0][i1].length;i2++){
	* result[i0][i1][i2] = translate(role[i0][i1][i2]);
	* }
	* ...
	* }
	* }
	* @param currentDimension counter for recursion only. invoke initially with 0.
	* @param arrayDimensions maximum of dimensions of the array
	* @return the new created ForStatement with all subcycles
	*/
	private ForStatement generateForStatement(int currentDimension, int arrayDimensions, AstGenerator gen)
	{

	Statement[] init = new Statement[1];
	char[] name = generateArrayIndexName(currentDimension);

	LocalDeclaration initializer = new LocalDeclaration(name,0,0);
	initializer.initialization = IntLiteral.buildIntLiteral("0".toCharArray(),0,0); //$NON-NLS-1$
	initializer.type = new SingleTypeReference(TypeConstants.INT, 0);
	init[0] = initializer;

	SingleNameReference condLeft = new SingleNameReference(name,0);

	FieldReference condRight = new FieldReference(IOTConstants.LENGTH,0);
	SingleNameReference roleNameReference = gen.singleNameReference(ROLE_ARRAY_ARG);
	decapsulationInput(roleNameReference);

	Expression lastArrayReference = roleNameReference;

	for (int idx = 0; idx < currentDimension; idx++) {
	SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
	ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
	lastArrayReference = nextArray;
	}
	condRight.receiver = lastArrayReference;

	Expression cond = new BinaryExpression(condLeft,condRight,OperatorIds.LESS);
	Statement[] inc = new Statement[1];

	inc[0]= new PostfixExpression(new SingleNameReference(name,0),IntLiteral.One,OperatorIds.PLUS,0);

	Block action = new Block(0);

	// result = new Base[role.length][][];
	Assignment arrayInstantiation =
	generateArrayInstantiation(currentDimension+1, arrayDimensions, gen);

	// if(r1 == null)continue;
	IfStatement ifStatement =
	generateIfStatement(currentDimension+1, arrayDimensions);

	if(currentDimension<arrayDimensions-1)
	{
	ForStatement innerForStatement = generateForStatement(currentDimension + 1, arrayDimensions, gen);
	action.statements = new Statement[3];
	action.statements[0] = ifStatement;
	action.statements[1] = arrayInstantiation;
	action.statements[2] = innerForStatement;
	}
	else
	{
	action.statements = new Statement[2];
	action.statements[0] = ifStatement;
	action.statements[1] = arrayInstantiation;
	}

	// for(;i0 < role.length;i0++)
	ForStatement outerForStatement = new ForStatement(init,cond, inc, action, true,0,0);

	return outerForStatement;
	}
	/**
	* creates AST-Element
	*
	* if currentDimension == 1 -> result = new Base[role.length][][];
	* if currentDimension == 2 -> result[i0] = new Base[role[i0].length][][];
	* if currentDimension == arrayDimensions -> result[i0][i1][i2] = role[i0][i1][i2]._OT$Base;
	* @param currentDimension some dimensions must have special treatment
	* @param arrayDimensions maximum of dimensions of the array
	* @return the new created assignment
	*/
	private Assignment generateArrayInstantiation(int currentDimension, int arrayDimensions, AstGenerator gen)
	{

	SingleNameReference resultNameReference = new SingleNameReference(IOTConstants.OT_RESULT,0);
	decapsulationOutput(resultNameReference);

	Expression lastArrayReference = resultNameReference;

	for (int idx = 0; idx < currentDimension; idx++) {
	SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
	ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
	lastArrayReference = nextArray;
	}
	Expression lhsReference = lastArrayReference;

	lastArrayReference = decapsulationInput(gen.singleNameReference(ROLE_ARRAY_ARG));

	for (int idx = 0; idx < currentDimension; idx++) {
	SingleNameReference pos = new SingleNameReference(generateArrayIndexName(idx),0);
	ArrayReference nextArray = new ArrayReference(lastArrayReference,pos);
	lastArrayReference = nextArray;
	}
	Expression rhsReference = lastArrayReference;

	if(currentDimension == arrayDimensions)
	{
	return new Assignment(
	lhsReference,
	translation(rhsReference, this._providedType.leafComponentType(), this._requiredType.leafComponentType()),
	0);
	}
	else
	{
	//new Required[role[i0].length][][];
	FieldReference lengthFieldReference = new FieldReference(IOTConstants.LENGTH,0);
	lengthFieldReference.receiver = rhsReference;


	TypeReference reqTypeReference = gen.typeReference(this._requiredType.leafComponentType());
	decapsulationOutput(reqTypeReference);

	ArrayAllocationExpression reqAllocationExpression = new ArrayAllocationExpression();
	reqAllocationExpression.type = reqTypeReference;
	reqAllocationExpression.dimensions = new Expression[arrayDimensions-currentDimension];
	reqAllocationExpression.dimensions[0] = lengthFieldReference;

	Assignment assignment = new Assignment(lhsReference,reqAllocationExpression,0);
	return assignment;
	}
	}

	/**
	* Hook method to fill in the atomic translation of one object.
	* @param rhs
	* @param providedType
	* @param requiredType
	* @return expression translating a single object
	*/
	abstract Expression translation(Expression rhs, TypeBinding providedType, TypeBinding requiredType);
	private MethodDeclaration generateTransformArrayMethod(
	TypeDeclaration teamType,
	char[] transformMethodName,
	int arrayDimensions)
	{
	AstGenerator gen = new AstGenerator(teamType.sourceStart, teamType.sourceEnd);

	MethodDeclaration transformArrayMethod = gen.method(
	teamType.compilationResult(),
	0, // modifiers
	this._requiredType,
	transformMethodName,
	new Argument[] {
	gen.argument(
	ROLE_ARRAY_ARG,
	gen.typeReference(this._providedType))
	});
	decapsulationInput(transformArrayMethod.arguments[0].type);
	decapsulationOutput(transformArrayMethod.returnType);

	// if(r1 == null)return null;
	IfStatement ifStatement =
	generateIfStatement(0, arrayDimensions);

	// Base[][][] result = null;
	LocalDeclaration reqArrayDeclaration =
	gen.localVariable(IOTConstants.OT_RESULT, this._requiredType, gen.nullLiteral());
	decapsulationOutput(reqArrayDeclaration.type);

	// result = new Base[role.length][][];
	Assignment arrayInstantiation =
	generateArrayInstantiation(0,arrayDimensions, gen);

	// for(...){...}
	ForStatement forStatement =
	generateForStatement(0,arrayDimensions, gen);

	// return result;
	ReturnStatement returnStatement =
	gen.returnStatement(gen.singleNameReference(IOTConstants.OT_RESULT));


	transformArrayMethod.setStatements(new Statement[] {
	ifStatement,
	reqArrayDeclaration,
	arrayInstantiation,
	forStatement,
	returnStatement});

	return transformArrayMethod;
	}
	}