| /******************************************************************************* |
| * Copyright (c) 2005-2014 Obeo |
| * |
| * 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.sirius.query.legacy.gen.template.scripts.imports.services; |
| |
| import java.util.Comparator; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.TreeSet; |
| |
| import org.eclipse.emf.ecore.EObject; |
| |
| import org.eclipse.sirius.query.legacy.ecore.factories.EFactory; |
| import org.eclipse.sirius.query.legacy.ecore.factories.FactoryException; |
| import org.eclipse.sirius.query.legacy.gen.AcceleoGenMessages; |
| import org.eclipse.sirius.query.legacy.gen.template.TemplateSyntaxException; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENode; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeCastException; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeException; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeIterator; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.ENodeList; |
| import org.eclipse.sirius.query.legacy.gen.template.eval.LaunchManager; |
| import org.eclipse.sirius.query.legacy.gen.template.expressions.TemplateExpression; |
| import org.eclipse.sirius.query.legacy.gen.template.scripts.IScript; |
| import org.eclipse.sirius.query.legacy.tools.format.Conventions; |
| import org.eclipse.sirius.query.legacy.tools.strings.Int2; |
| |
| /** |
| * System services for ENode elements. |
| * |
| * |
| */ |
| public class ENodeServices { |
| |
| /** |
| * The script. |
| */ |
| protected IScript script; |
| |
| /** |
| * Constructor. |
| * |
| * @param script |
| * is the script |
| */ |
| public ENodeServices(IScript script) { |
| this.script = script; |
| } |
| |
| /** |
| * Gets all the nodes whose type is the given type. |
| * <p> |
| * An element is kept only if it's an EObject whose type is the given type |
| * or if it isn't an EObject. |
| * <p> |
| * Sample : |
| * <p> |
| * <li>a is an instance of class A</li> |
| * <li>b is an instance of class B</li> |
| * <li>c is an instance of class C</li> |
| * <li>B extends A</li> |
| * <p> |
| * If type equals "A" and node is a list {a, "\n", b, c} |
| * <p> |
| * the result is a list {a, "\n", b}. |
| * |
| * @param node |
| * is the list |
| * @param type |
| * is the type kept |
| * @return a list that contains the nodes whose type is the given type. |
| * @throws ENodeCastException |
| * if the given node isn't a list |
| * @throws FactoryException |
| */ |
| public ENode filter(ENode node, String type) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList res = new ENodeList(); |
| ENodeIterator it = node.getList().iterator(); |
| while (it.hasNext()) { |
| ENode child = filter(it.next(), type); |
| if (!child.isNull()) { |
| res.add(child); |
| } |
| } |
| return new ENode(res, node); |
| } else if (node.isEObject()) { |
| if (EFactory.eInstanceOf(node.getEObject(), type)) { |
| return node; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } else { |
| return node; |
| } |
| } |
| |
| /** |
| * Gets all the nodes whose type is the given type. |
| * <p> |
| * An element is kept only if it's an EObject whose type is the given type |
| * or if it isn't an EObject. |
| * <p> |
| * Sample : |
| * <p> |
| * <li>a is an instance of class A</li> |
| * <li>b is an instance of class B</li> |
| * <li>c is an instance of class C</li> |
| * <li>B extends A</li> |
| * <p> |
| * If type equals "A" and node is a list {a, "\n", b, c} |
| * <p> |
| * the result is a list {a, "\n", b}. |
| * |
| * @param node |
| * is the list |
| * @param type |
| * is the type kept |
| * @return a list that contains the nodes whose type is the given type. |
| * @throws ENodeCastException |
| * if the given node isn't a list |
| * @throws FactoryException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode cast(ENode node, String type) throws ENodeCastException, FactoryException { |
| return filter(node, type); |
| } |
| |
| /** |
| * Add a separator between each element of the list. It returns the given |
| * node if it isn't a list. |
| * <p> |
| * Sample : |
| * <p> |
| * If separator equals "\t" and node is a list {a, b, c} the result is a |
| * list {a, "\t", b, "\t", c}. |
| * |
| * @param node |
| * is the list |
| * @param separator |
| * is the separator |
| * @return a list that contains a separator between each element. |
| * @throws FactoryException |
| */ |
| public ENode sep(ENode node, String separator) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList list = node.getList(); |
| ENodeList res = new ENodeList(); |
| ENodeIterator it = list.iterator(); |
| if (it.hasNext()) { |
| ENode element = it.next(); |
| boolean needSeparator = element.size() > 0; |
| res.add(element); |
| while (it.hasNext()) { |
| element = it.next(); |
| if (needSeparator && element.size() > 0) { |
| res.add(new ENode(separator, node)); |
| needSeparator = true; |
| } else if (!needSeparator) { |
| needSeparator = element.size() > 0; |
| } |
| res.add(element); |
| } |
| } |
| return new ENode(res, node); |
| } else { |
| return node; |
| } |
| } |
| |
| /** |
| * Add a separator between each element of the list and serialize the list. |
| * It returns node.toString() if it isn't a list. |
| * <p> |
| * Sample : |
| * <p> |
| * If separator equals "\t" and node is a list {a, b, c} the result is a |
| * string : a + "\t" + b + "\t" + c. |
| * |
| * @param node |
| * is the list |
| * @param separator |
| * is the separator |
| * @return a string that contains a separator between each element. |
| * @throws FactoryException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode sepStr(ENode node, String separator) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList list = node.getList(); |
| ENodeList res = new ENodeList(); |
| ENodeIterator it = list.iterator(); |
| if (it.hasNext()) { |
| ENode element = it.next(); |
| boolean needSeparator = element.size() > 0; |
| res.add(element); |
| while (it.hasNext()) { |
| element = it.next(); |
| if (needSeparator && element.size() > 0) { |
| res.add(new ENode(separator, node)); |
| needSeparator = true; |
| } else if (!needSeparator) { |
| needSeparator = element.size() > 0; |
| } |
| res.add(element); |
| } |
| } |
| ENode result = new ENode(res, node); |
| result.asString(); |
| return result; |
| } else { |
| node.asString(); |
| return node; |
| } |
| } |
| |
| /** |
| * Get recursively the feature value of an object. The recursivity is |
| * stopped when an element of the given type is found. |
| * <p> |
| * The given node must be an EObject. |
| * <p> |
| * Sample : |
| * <p> |
| * <li>a is an instance of class A</li> |
| * <li>b is an instance of class B</li> |
| * <li>c is an instance of class C</li> |
| * <li>a contains b</li> |
| * <li>b contains c</li> |
| * <li>'container' feature is defined on a, b, and c</li> |
| * <li>c.container returns b</li> |
| * <li>b.container returns a</li> |
| * <li>a.container returns null</li> |
| * <p> |
| * until(c,"container","A") returns a |
| * <p> |
| * until(b,"container","A") returns a |
| * <p> |
| * until(a,"container","A") returns a |
| * <p> |
| * until(b,"container","C") returns null |
| * <p> |
| * |
| * @param node |
| * is an EObject |
| * @param link |
| * is the feature name |
| * @param type |
| * is the type which stops the recursivity |
| * @return the found object or null |
| * @throws ENodeCastException |
| * if the given node isn't an EObject |
| * @throws FactoryException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode until(ENode node, String link, String type) throws ENodeCastException, FactoryException { |
| EObject object = node.getEObject(); |
| while (object != null) { |
| if (EFactory.eInstanceOf(object, type)) { |
| return new ENode(object, node); |
| } else { |
| object = EFactory.eGetAsEObject(object, link); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the current node. |
| * |
| * @param node |
| * is the current node |
| * @return the current node |
| */ |
| public ENode current(ENode node) { |
| return node; |
| } |
| |
| /** |
| * Returns the current node. |
| * |
| * @param node |
| * is the current node |
| * @param level |
| * is the level in the parent hierarchy |
| * @return the current node |
| * @throws ENodeCastException |
| */ |
| public ENode current(ENode node, ENode arg) throws ENodeCastException { |
| if (arg.isString()) { |
| String type = arg.getString(); |
| int i = 0; |
| Object value = script.contextAt(IScript.TEMPLATE_NODE, i); |
| while (value != null) { |
| ENode current = ENode.createTry(value, node); |
| if (current != null && current.isEObject()) { |
| if (EFactory.eInstanceOf(current.getEObject(), type)) { |
| return current; |
| } |
| } |
| i++; |
| value = script.contextAt(IScript.TEMPLATE_NODE, i); |
| } |
| } else if (arg.isInt()) { |
| Object value = script.contextAt(IScript.TEMPLATE_NODE, arg.getInt()); |
| return ENode.createTry(value, node); |
| } |
| return new ENode(ENode.EMPTY, node); |
| } |
| |
| /** |
| * Transforms the node into a string. |
| * |
| * @param node |
| * is the current node |
| * @return the string node |
| */ |
| public ENode toString(ENode node) { |
| node.asString(); |
| return node; |
| } |
| |
| /** |
| * Returns the adaptive value for the given type short name. |
| * |
| * @param node |
| * is the node |
| * @param type |
| * is the type name : "EObject", "ENodeList", "String", |
| * "boolean", "int", "double", "List", "ENode" |
| * @return the adaptive value |
| * @throws ENodeCastException |
| */ |
| public ENode adapt(ENode node, String type) throws ENodeCastException { |
| Class c; |
| if ("EObject".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = EObject.class; |
| } else if ("ENodeList".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = ENodeList.class; |
| } else if ("String".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = String.class; |
| } else if ("boolean".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = boolean.class; |
| } else if ("int".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = int.class; |
| } else if ("double".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = double.class; |
| } else if ("List".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = List.class; |
| } else if ("ENode".equalsIgnoreCase(type)) { //$NON-NLS-1$ |
| c = ENode.class; |
| } else { |
| c = null; |
| } |
| ENode result = ENode.createTry(node.getAdapterValue(c), node); |
| if (result != null) { |
| return result; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } |
| |
| /** |
| * It prints current node. |
| * |
| * @param node |
| * is the current node |
| * @return the current node |
| */ |
| public ENode debug(ENode node) { |
| return trace(node); |
| } |
| |
| /** |
| * It prints current node. |
| * |
| * @param node |
| * is the current node |
| * @return the current node |
| */ |
| public ENode trace(ENode node) { |
| return trace(node, ""); //$NON-NLS-1$ |
| } |
| |
| /** |
| * It prints current node. |
| * |
| * @param node |
| * is the current node |
| * @param template |
| * is the template to evaluate for each node |
| * @return the current node |
| */ |
| public ENode trace(ENode node, String template) { |
| trace++; |
| String prefix; |
| if (template != null && template.length() > 0) { |
| try { |
| prefix = Conventions.formatString(template) + '=' + Conventions.formatString(evaluate(node, template).toString()); |
| } catch (TemplateSyntaxException e) { |
| prefix = ""; //$NON-NLS-1$ |
| } catch (FactoryException e) { |
| prefix = ""; //$NON-NLS-1$ |
| } |
| } else { |
| prefix = ""; //$NON-NLS-1$ |
| } |
| String marker = ('[' + trace + "] ").substring(0, 10); //$NON-NLS-1$ |
| System.out.println(marker + prefix + ' ' + AcceleoGenMessages.getString("ENodeServices.TraceMessage", new Object[] { node.getType(), Conventions.formatString(node.toString()), })); //$NON-NLS-1$ |
| return node; |
| } |
| |
| private int trace = 0; |
| |
| private ENode evaluate(ENode current, String call) throws TemplateSyntaxException, FactoryException { |
| int pos = getBegin(); |
| call = call.replaceAll("'", "\\\""); //$NON-NLS-1$ //$NON-NLS-2$ |
| TemplateExpression expression = TemplateExpression.fromString(computeCall(pos, call), new Int2(pos, pos + call.length()), script); |
| try { |
| return expression.evaluate(current, script, LaunchManager.create("run", true)); //$NON-NLS-1$ |
| } catch (ENodeException e) { |
| return new ENode(ENode.EMPTY, current); |
| } |
| } |
| |
| private int getBegin() { |
| Int2 pos = (Int2) script.contextPeek(IScript.ARGUMENT_POSITION); |
| if (pos != null) { |
| return pos.b(); |
| } else { |
| return 0; |
| } |
| } |
| |
| private String computeCall(int begin, String call) { |
| if (begin > 0) { |
| StringBuffer result = new StringBuffer(""); //$NON-NLS-1$ |
| for (int i = 0; i < begin; i++) { |
| result.append(' '); |
| } |
| result.append(call); |
| return result.toString(); |
| } else { |
| return call; |
| } |
| } |
| |
| /*************************************************************************** |
| * |
| * List Services |
| * |
| **************************************************************************/ |
| |
| /** |
| * Returns the size of the node. |
| * |
| * @param node |
| * is the current node <li>isEObject() : return 1</li> <li> |
| * isList() : return getList().size()</li> <li>isString() : |
| * return getString().length()</li> <li>isBoolean() : return 1</li> |
| * <li>isInt() : return 1</li> <li>isNull() : return 0</li> |
| * @return value size |
| */ |
| public int nSize(ENode node) { |
| return node.size(); |
| } |
| |
| /** |
| * Returns the child node at the given index in the current node. |
| * |
| * @param node |
| * is the current node |
| * @param index |
| * is the index of the child |
| * @return the child node |
| * @throws ENodeCastException |
| * @throws FactoryException |
| */ |
| public ENode nGet(ENode node, int index) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList list = node.getList(); |
| ENode result = list.get(index); |
| if (result != null) { |
| return result; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } else if (index == 0) { |
| return node; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } |
| |
| /** |
| * Returns the children in the given range. |
| * |
| * @param node |
| * is the current node |
| * @param begin |
| * is the beginning index |
| * @param begin |
| * is the ending index |
| * @return the children in the given range |
| * @throws ENodeCastException |
| * @throws FactoryException |
| */ |
| public ENode nGet(ENode node, int begin, int end) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList list = node.getList(); |
| ENodeList result = new ENodeList(); |
| for (int i = begin; i < list.size() && (i < end || end == -1); i++) { |
| ENode child = list.get(i); |
| result.add(child); |
| } |
| return new ENode(result, node); |
| } else if (begin == 0 && (end > 0 || end == -1)) { |
| return node; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } |
| |
| /** |
| * Returns the first child of the current node. |
| * |
| * @param node |
| * is the current node |
| * @return the first child node |
| * @throws ENodeCastException |
| * @throws FactoryException |
| */ |
| public ENode nFirst(ENode node) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList list = node.getList(); |
| ENode result = list.get(0); |
| if (result != null) { |
| return result; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } else { |
| return node; |
| } |
| } |
| |
| /** |
| * Returns the last child of the current node. |
| * |
| * @param node |
| * is the current node |
| * @return the last child node |
| * @throws ENodeCastException |
| * @throws FactoryException |
| */ |
| public ENode nLast(ENode node) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList list = node.getList(); |
| ENode result = list.get(list.size() - 1); |
| if (result != null) { |
| return result; |
| } else { |
| return new ENode(ENode.EMPTY, node); |
| } |
| } else { |
| return node; |
| } |
| } |
| |
| /** |
| * Removes all duplicated nodes. |
| * |
| * @param node |
| * is the current node |
| * @return the minimized node |
| * @throws ENodeCastException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode minimize(ENode node) throws ENodeCastException { |
| return nMinimize(node); |
| } |
| |
| /** |
| * Removes all duplicated nodes. |
| * |
| * @param node |
| * is the current node |
| * @return the minimized node |
| * @throws ENodeCastException |
| */ |
| public ENode nMinimize(ENode node) throws ENodeCastException { |
| if (node.isList()) { |
| ENodeList result = new ENodeList(true); |
| result.addAll(node.getList()); |
| return new ENode(result, node); |
| } else { |
| return node; |
| } |
| } |
| |
| /** |
| * Reverses the order of the elements of the specified node. |
| * |
| * @param node |
| * is the node whose elements are to be reversed |
| * @return the new node |
| * @throws ENodeCastException |
| * @throws FactoryException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode reverse(ENode node) throws ENodeCastException, FactoryException { |
| return nReverse(node); |
| } |
| |
| /** |
| * Reverses the order of the elements of the specified node. |
| * |
| * @param node |
| * is the node whose elements are to be reversed |
| * @return the new node |
| * @throws ENodeCastException |
| * @throws FactoryException |
| */ |
| public ENode nReverse(ENode node) throws ENodeCastException, FactoryException { |
| if (node.isList()) { |
| ENodeList result = new ENodeList(); |
| ENodeIterator it = node.getList().iterator(); |
| while (it.hasNext()) { |
| ENode child = it.next(); |
| if (!child.isNull()) { |
| result.add(0, child); |
| } |
| } |
| return new ENode(result, node); |
| } else { |
| return node; |
| } |
| } |
| |
| /** |
| * Returns true if this list contains the specified element. |
| * <p> |
| * More formally, returns true if and only if this list contains at least |
| * <p> |
| * one element e such that (o==null ? e==null : o.equals(e)). |
| * |
| * @param node |
| * is the current node |
| * @param element |
| * is element whose presence in this list is to be tested |
| * @return true if this list contains the specified element |
| * @throws ENodeCastException |
| */ |
| public boolean nContains(ENode node, ENode element) throws ENodeCastException { |
| if (node.isList()) { |
| return node.getList().contains(element); |
| } else { |
| return node.equals(element); |
| } |
| } |
| |
| /** |
| * Sorts the node and its children. |
| * |
| * @param node |
| * is the current node |
| * @return the sorted node |
| * @throws ENodeCastException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode sort(ENode node) throws ENodeCastException { |
| return nMinimize(nSort(node)); |
| } |
| |
| /** |
| * Sorts the node and its children. |
| * |
| * @param node |
| * is the current node |
| * @return the sorted node |
| * @throws ENodeCastException |
| */ |
| public ENode nSort(ENode node) throws ENodeCastException { |
| if (node.isList()) { |
| node.getList().sort(); |
| } |
| return node; |
| } |
| |
| /** |
| * Sorts the node and its children. |
| * |
| * @param current |
| * is the current node of generation |
| * @param call |
| * is the expression to evaluate for each node |
| * @return the sorted node |
| * @throws ENodeCastException |
| * @deprecated |
| */ |
| @Deprecated |
| public ENode sort(ENode current, String call) throws ENodeCastException { |
| return nMinimize(nSort(current, call)); |
| } |
| |
| /** |
| * Sorts the node and its children. |
| * |
| * @param current |
| * is the current node of generation |
| * @param call |
| * is the expression to evaluate for each node |
| * @return the sorted node |
| * @throws ENodeCastException |
| */ |
| public ENode nSort(ENode current, String call) throws ENodeCastException { |
| final String template = call; |
| if (current.isList()) { |
| Set set = new TreeSet(new Comparator() { |
| public int compare(Object arg0, Object arg1) { |
| ENode n0; |
| try { |
| n0 = evaluate((ENode) arg0, template); |
| } catch (TemplateSyntaxException e) { |
| n0 = new ENode(ENode.EMPTY, (ENode) arg0); |
| } catch (FactoryException e) { |
| n0 = new ENode(ENode.EMPTY, (ENode) arg0); |
| } |
| ENode n1; |
| try { |
| n1 = evaluate((ENode) arg1, template); |
| } catch (TemplateSyntaxException e) { |
| n1 = new ENode(ENode.EMPTY, (ENode) arg1); |
| } catch (FactoryException e) { |
| n1 = new ENode(ENode.EMPTY, (ENode) arg1); |
| } |
| return n0.compareTo(n1); |
| } |
| }); |
| ENodeIterator it = current.getList().iterator(); |
| while (it.hasNext()) { |
| set.add(it.next()); |
| } |
| ENodeList result = new ENodeList(); |
| Iterator elements = set.iterator(); |
| while (elements.hasNext()) { |
| result.add((ENode) elements.next()); |
| } |
| return new ENode(result, current); |
| } else { |
| return current; |
| } |
| } |
| |
| } |
