org.eclipse.emf.ecoretools.design/src/org/eclipse/emf/ecoretools/design/service/EOperationServices.java - gerrit/ecoretools/org.eclipse.ecoretools - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013 THALES GLOBAL SERVICES and Others
  * 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
  *
  * Contributors:
  *     Obeo - initial API and implementation
  *******************************************************************************/
 package org.eclipse.emf.ecoretools.design.service;

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

 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.ENamedElement;
 import org.eclipse.emf.ecore.EOperation;
 import org.eclipse.emf.ecore.EParameter;
 import org.eclipse.emf.ecore.ETypedElement;
 import org.eclipse.emf.ecore.EcoreFactory;

 import com.google.common.base.Function;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Ordering;

 /**
  * Services dealing with EOperations usable from a VSM.
  */
 public class EOperationServices {
 	private static final String TYPE_SEPARATOR = ":";

 	private static final String PARAMETERS_SEPARATOR = ",";

 	/**
 	 * Computes the label of an EOperation.
 	 */
 	public String render(EOperation op) {
 		StringBuilder sb = new StringBuilder();
 		renderName(op, sb);
 		renderParameters(op, sb, true);
 		renderType(op, sb);
 		return sb.toString();
 	}

 	/**
 	 * Computes the tooltip of an EOperation (same as label but excluding the
 	 * parameters Types) .
 	 *
 	 * @param op
 	 *            the operation to be rendered
 	 * @return the tooltip of the given EOperation (same as label but excluding
 	 *         the parameters Types)
 	 */
 	public String renderEOperationTooltip(EOperation op) {
 		StringBuilder sb = new StringBuilder();
 		renderName(op, sb);
 		renderParameters(op, sb, false);
 		renderType(op, sb);
 		return sb.toString();
 	}

 	/**
 	 * Performs a "direct edit" operation on an EOperation.
 	 */
 	public EOperation performEdit(EOperation op, String editString) {
 		editName(op, editString);
 		editParameters(op, editString);
 		editType(op, editString);
 		return op;
 	}

 	private void renderName(EOperation op, StringBuilder sb) {
 		if (op.getName() != null) {
 			sb.append(op.getName());
 		}
 	}

 	/**
 	 * Renders the parameters of the given EOperation.
 	 *
 	 * @param op
 	 *            the operation to render
 	 * @param sb
 	 *            the string builder used to render the eOperation
 	 * @param includeParameterType
 	 *            indicates whether parameter's Types should be rendered or not
 	 */
 	private void renderParameters(EOperation op, StringBuilder sb,
 			boolean includeParameterType) {
 		sb.append("(");
 		boolean first = true;
 		for (EParameter param : op.getEParameters()) {
 			if (!first) {
 				sb.append(PARAMETERS_SEPARATOR).append(" ");
 			} else {
 				first = false;
 			}
 			sb.append(renderParameter(param, includeParameterType));
 		}
 		sb.append(")");
 	}

 	/**
 	 * Renders the given Parameter.
 	 *
 	 * @param parameter
 	 *            the parameter to render
 	 * @param includeParameterType
 	 *            indicates whether parameter's Type should be rendered or not
 	 */
 	private String renderParameter(EParameter parameter,
 			boolean includeParameterType) {
 		String name = parameter.getName();
 		String typeName = EGenericsServices.getETypeLabel(parameter);
 		if (name != null && typeName != null && includeParameterType) {
 			return parameter.getName() + " " + typeName;
 		} else if (name != null) {
 			return parameter.getName();
 		} else {
 			return "";
 		}
 	}

 	private void renderType(EOperation op, StringBuilder sb) {
 		String typeLabel = EGenericsServices.getETypeLabel(op);
 		if (typeLabel != null) {
 			sb.append(" ").append(TYPE_SEPARATOR).append(" ");
 			sb.append(typeLabel);
 		}
 	}

 	private void editName(EOperation op, String editString) {
 		int nameEnd = editString.length();
 		int typeStart = editString.indexOf(TYPE_SEPARATOR);
 		if (typeStart != -1) {
 			nameEnd = Math.min(nameEnd, typeStart);
 		}
 		int paramStart = editString.indexOf("(");
 		if (paramStart != -1) {
 			nameEnd = Math.min(nameEnd, paramStart);
 		}

 		String namePart = editString.substring(0, nameEnd);
 		if (namePart.trim().length() > 0) {
 			op.setName(namePart.trim());
 		} else if (typeStart == -1 && paramStart == -1) {
 			// Reset the name only if no other parts have been specified.
 			op.setName(null);
 		}
 	}

 	private void editParameters(EOperation op, String editString) {
 		int paramStart = editString.indexOf("(");
 		int paramEnd = editString.lastIndexOf(")");
 		if (paramStart != -1 && paramEnd != -1 && paramStart < paramEnd) {
 			List<String[]> spec = parseParameters(editString.substring(
 					paramStart + 1, paramEnd));
 			int nbParam = spec.size();
 			// Remove parameters from the end if we have too many.
 			for (int i = op.getEParameters().size() - 1; i >= nbParam; i--) {
 				op.getEParameters().remove(i);
 			}
 			// Update existing parameters with new spec and append additional
 			// ones if necessary
 			for (int i = 0; i < nbParam; i++) {
 				EParameter param = null;
 				if (i < op.getEParameters().size()) {
 					param = op.getEParameters().get(i);
 				} else {
 					param = EcoreFactory.eINSTANCE.createEParameter();
 					op.getEParameters().add(param);
 				}
 				updateParameter(op, param, spec.get(i));
 			}
 		}
 	}

 	private void updateParameter(EOperation op, EParameter param,
 			String[] paramSpec) {
 		if (paramSpec[0] != null) {
 			param.setName(paramSpec[0]);
 		}
 		if (paramSpec[1] != null) {
 			EClassifier type = new DesignServices().findTypeByName(op,
 					paramSpec[1]);
 			if (type != null) {
 				param.setEType(type);
 			}
 		}
 	}

 	private List<String[]> parseParameters(String spec) {
 		List<String[]> result = new ArrayList<String[]>();
 		if (spec.contains(PARAMETERS_SEPARATOR)) {
 			String[] params = spec.split(PARAMETERS_SEPARATOR);
 			for (String paramSpec : params) {
 				result.add(parseParameter(paramSpec));
 			}
 		} else if (spec.trim().length() > 0) {
 			result.add(parseParameter(spec));
 		}
 		return result;
 	}

 	/**
 	 * Parses a single parameter specification. Supports the following syntaxes:
 	 *
 	 * <pre>
 	 * "name"
 	 * "name Type"
 	 * "name : Type"
 	 * " : Type"
 	 * </pre>
 	 *
 	 * Returns an array of two strings, representing the parameter name and the
 	 * type name. Both can be <code>null</code> if the corresponding part is not
 	 * specified.
 	 *
 	 * Note: this method is public only so that it can be visible from tests.
 	 */
 	public String[] parseParameter(String paramSpec) {
 		String[] type = null;
 		// Try ":" as type separator
 		int typeStart = paramSpec.indexOf(TYPE_SEPARATOR);
 		if (typeStart != -1) {
 			type = splitParameterSpec(paramSpec, typeStart);
 		} else {
 			// If there is no ":", assume whitespace separates the name from the
 			// type
 			paramSpec = paramSpec.trim();
 			typeStart = paramSpec.lastIndexOf(" ");
 			if (typeStart != -1) {
 				type = splitParameterSpec(paramSpec, typeStart);
 			} else {
 				typeStart = paramSpec.lastIndexOf("\t");
 				if (typeStart != -1) {
 					type = splitParameterSpec(paramSpec, typeStart);
 				}
 			}
 		}
 		// If there was neither ":" nor space, the spec can specify only the
 		// name, or maybe nothing if it is blank.
 		if (type == null) {
 			String name = paramSpec.trim();
 			if (name.length() == 0) {
 				name = null;
 			}
 			type = new String[] { name, null };
 		}
 		return type;
 	}

 	public List<ENamedElement> getAllAssociatedElements(EOperation op) {
 		// [eParameters->including(self)->asSequence()->sortedBy(name)/]
 		List<ENamedElement> result = Lists.newArrayListWithExpectedSize(1 + op
 				.getEParameters().size());
 		result.add(op);
 		result.addAll(op.getEParameters());
 		Collections.sort(
 				result,
 				Ordering.natural().onResultOf(
 						new Function<ENamedElement, String>() {
 							public String apply(ENamedElement input) {
 								return input.getName();
 							}
 						}));
 		return result;
 	}

 	private String[] splitParameterSpec(String paramSpec, int typeStart) {
 		String[] type;
 		String name;
 		String typeName;
 		name = paramSpec.substring(0, typeStart).trim();
 		if (typeStart != paramSpec.length() - 1) {
 			typeName = paramSpec.substring(typeStart + 1).trim();
 		} else {
 			typeName = null;
 		}
 		if (name.length() == 0) {
 			name = null;
 		}
 		if (typeName != null && typeName.length() == 0) {
 			typeName = null;
 		}
 		type = new String[] { name, typeName };
 		return type;
 	}

 	private void editType(EOperation op, String editString) {
 		Object value = getSpecifiedType(op, editString);
 		if (value != null) {
 			EGenericsServices.setETypeWithGenerics(op, value);
 		} else {
 			// Only reset the type to null if the ":" is explicitly present with
 			// no type specified
 			int typeStart = editString.lastIndexOf(TYPE_SEPARATOR);
 			if (typeStart != -1
 					&& !editString.substring(typeStart).contains(")")) {
 				op.setEType(null);
 			}
 		}
 	}

 	private Object getSpecifiedType(ETypedElement receiver, String editString) {
 		int typeStart = editString.lastIndexOf(TYPE_SEPARATOR);
 		if (typeStart != -1 && editString.length() > typeStart + 1) {
 			String typeName = editString.substring(typeStart + 1).trim();
 			if (!typeName.contains(")")) {
 				Object value = EGenericsServices.findGenericType(receiver,
 						typeName);
 				if (value == null) {
 					value = new DesignServices().findTypeByName(receiver,
 							typeName);
 				}
 				return value;
 			}
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2013 THALES GLOBAL SERVICES and Others
	* 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
	*
	* Contributors:
	* Obeo - initial API and implementation
	*******************************************************************************/
	package org.eclipse.emf.ecoretools.design.service;

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

	import org.eclipse.emf.ecore.EClassifier;
	import org.eclipse.emf.ecore.ENamedElement;
	import org.eclipse.emf.ecore.EOperation;
	import org.eclipse.emf.ecore.EParameter;
	import org.eclipse.emf.ecore.ETypedElement;
	import org.eclipse.emf.ecore.EcoreFactory;

	import com.google.common.base.Function;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Ordering;

	/**
	* Services dealing with EOperations usable from a VSM.
	*/
	public class EOperationServices {
	private static final String TYPE_SEPARATOR = ":";

	private static final String PARAMETERS_SEPARATOR = ",";

	/**
	* Computes the label of an EOperation.
	*/
	public String render(EOperation op) {
	StringBuilder sb = new StringBuilder();
	renderName(op, sb);
	renderParameters(op, sb, true);
	renderType(op, sb);
	return sb.toString();
	}

	/**
	* Computes the tooltip of an EOperation (same as label but excluding the
	* parameters Types) .
	*
	* @param op
	* the operation to be rendered
	* @return the tooltip of the given EOperation (same as label but excluding
	* the parameters Types)
	*/
	public String renderEOperationTooltip(EOperation op) {
	StringBuilder sb = new StringBuilder();
	renderName(op, sb);
	renderParameters(op, sb, false);
	renderType(op, sb);
	return sb.toString();
	}

	/**
	* Performs a "direct edit" operation on an EOperation.
	*/
	public EOperation performEdit(EOperation op, String editString) {
	editName(op, editString);
	editParameters(op, editString);
	editType(op, editString);
	return op;
	}

	private void renderName(EOperation op, StringBuilder sb) {
	if (op.getName() != null) {
	sb.append(op.getName());
	}
	}

	/**
	* Renders the parameters of the given EOperation.
	*
	* @param op
	* the operation to render
	* @param sb
	* the string builder used to render the eOperation
	* @param includeParameterType
	* indicates whether parameter's Types should be rendered or not
	*/
	private void renderParameters(EOperation op, StringBuilder sb,
	boolean includeParameterType) {
	sb.append("(");
	boolean first = true;
	for (EParameter param : op.getEParameters()) {
	if (!first) {
	sb.append(PARAMETERS_SEPARATOR).append(" ");
	} else {
	first = false;
	}
	sb.append(renderParameter(param, includeParameterType));
	}
	sb.append(")");
	}

	/**
	* Renders the given Parameter.
	*
	* @param parameter
	* the parameter to render
	* @param includeParameterType
	* indicates whether parameter's Type should be rendered or not
	*/
	private String renderParameter(EParameter parameter,
	boolean includeParameterType) {
	String name = parameter.getName();
	String typeName = EGenericsServices.getETypeLabel(parameter);
	if (name != null && typeName != null && includeParameterType) {
	return parameter.getName() + " " + typeName;
	} else if (name != null) {
	return parameter.getName();
	} else {
	return "";
	}
	}

	private void renderType(EOperation op, StringBuilder sb) {
	String typeLabel = EGenericsServices.getETypeLabel(op);
	if (typeLabel != null) {
	sb.append(" ").append(TYPE_SEPARATOR).append(" ");
	sb.append(typeLabel);
	}
	}

	private void editName(EOperation op, String editString) {
	int nameEnd = editString.length();
	int typeStart = editString.indexOf(TYPE_SEPARATOR);
	if (typeStart != -1) {
	nameEnd = Math.min(nameEnd, typeStart);
	}
	int paramStart = editString.indexOf("(");
	if (paramStart != -1) {
	nameEnd = Math.min(nameEnd, paramStart);
	}

	String namePart = editString.substring(0, nameEnd);
	if (namePart.trim().length() > 0) {
	op.setName(namePart.trim());
	} else if (typeStart == -1 && paramStart == -1) {
	// Reset the name only if no other parts have been specified.
	op.setName(null);
	}
	}

	private void editParameters(EOperation op, String editString) {
	int paramStart = editString.indexOf("(");
	int paramEnd = editString.lastIndexOf(")");
	if (paramStart != -1 && paramEnd != -1 && paramStart < paramEnd) {
	List<String[]> spec = parseParameters(editString.substring(
	paramStart + 1, paramEnd));
	int nbParam = spec.size();
	// Remove parameters from the end if we have too many.
	for (int i = op.getEParameters().size() - 1; i >= nbParam; i--) {
	op.getEParameters().remove(i);
	}
	// Update existing parameters with new spec and append additional
	// ones if necessary
	for (int i = 0; i < nbParam; i++) {
	EParameter param = null;
	if (i < op.getEParameters().size()) {
	param = op.getEParameters().get(i);
	} else {
	param = EcoreFactory.eINSTANCE.createEParameter();
	op.getEParameters().add(param);
	}
	updateParameter(op, param, spec.get(i));
	}
	}
	}

	private void updateParameter(EOperation op, EParameter param,
	String[] paramSpec) {
	if (paramSpec[0] != null) {
	param.setName(paramSpec[0]);
	}
	if (paramSpec[1] != null) {
	EClassifier type = new DesignServices().findTypeByName(op,
	paramSpec[1]);
	if (type != null) {
	param.setEType(type);
	}
	}
	}

	private List<String[]> parseParameters(String spec) {
	List<String[]> result = new ArrayList<String[]>();
	if (spec.contains(PARAMETERS_SEPARATOR)) {
	String[] params = spec.split(PARAMETERS_SEPARATOR);
	for (String paramSpec : params) {
	result.add(parseParameter(paramSpec));
	}
	} else if (spec.trim().length() > 0) {
	result.add(parseParameter(spec));
	}
	return result;
	}

	/**
	* Parses a single parameter specification. Supports the following syntaxes:
	*
	* <pre>
	* "name"
	* "name Type"
	* "name : Type"
	* " : Type"
	* </pre>
	*
	* Returns an array of two strings, representing the parameter name and the
	* type name. Both can be <code>null</code> if the corresponding part is not
	* specified.
	*
	* Note: this method is public only so that it can be visible from tests.
	*/
	public String[] parseParameter(String paramSpec) {
	String[] type = null;
	// Try ":" as type separator
	int typeStart = paramSpec.indexOf(TYPE_SEPARATOR);
	if (typeStart != -1) {
	type = splitParameterSpec(paramSpec, typeStart);
	} else {
	// If there is no ":", assume whitespace separates the name from the
	// type
	paramSpec = paramSpec.trim();
	typeStart = paramSpec.lastIndexOf(" ");
	if (typeStart != -1) {
	type = splitParameterSpec(paramSpec, typeStart);
	} else {
	typeStart = paramSpec.lastIndexOf("\t");
	if (typeStart != -1) {
	type = splitParameterSpec(paramSpec, typeStart);
	}
	}
	}
	// If there was neither ":" nor space, the spec can specify only the
	// name, or maybe nothing if it is blank.
	if (type == null) {
	String name = paramSpec.trim();
	if (name.length() == 0) {
	name = null;
	}
	type = new String[] { name, null };
	}
	return type;
	}

	public List<ENamedElement> getAllAssociatedElements(EOperation op) {
	// [eParameters->including(self)->asSequence()->sortedBy(name)/]
	List<ENamedElement> result = Lists.newArrayListWithExpectedSize(1 + op
	.getEParameters().size());
	result.add(op);
	result.addAll(op.getEParameters());
	Collections.sort(
	result,
	Ordering.natural().onResultOf(
	new Function<ENamedElement, String>() {
	public String apply(ENamedElement input) {
	return input.getName();
	}
	}));
	return result;
	}

	private String[] splitParameterSpec(String paramSpec, int typeStart) {
	String[] type;
	String name;
	String typeName;
	name = paramSpec.substring(0, typeStart).trim();
	if (typeStart != paramSpec.length() - 1) {
	typeName = paramSpec.substring(typeStart + 1).trim();
	} else {
	typeName = null;
	}
	if (name.length() == 0) {
	name = null;
	}
	if (typeName != null && typeName.length() == 0) {
	typeName = null;
	}
	type = new String[] { name, typeName };
	return type;
	}

	private void editType(EOperation op, String editString) {
	Object value = getSpecifiedType(op, editString);
	if (value != null) {
	EGenericsServices.setETypeWithGenerics(op, value);
	} else {
	// Only reset the type to null if the ":" is explicitly present with
	// no type specified
	int typeStart = editString.lastIndexOf(TYPE_SEPARATOR);
	if (typeStart != -1
	&& !editString.substring(typeStart).contains(")")) {
	op.setEType(null);
	}
	}
	}

	private Object getSpecifiedType(ETypedElement receiver, String editString) {
	int typeStart = editString.lastIndexOf(TYPE_SEPARATOR);
	if (typeStart != -1 && editString.length() > typeStart + 1) {
	String typeName = editString.substring(typeStart + 1).trim();
	if (!typeName.contains(")")) {
	Object value = EGenericsServices.findGenericType(receiver,
	typeName);
	if (value == null) {
	value = new DesignServices().findTypeByName(receiver,
	typeName);
	}
	return value;
	}
	}
	return null;
	}
	}