| /***************************************************************************** |
| * Copyright (c) 2019 CEA LIST. |
| * |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Xavier Le Pallec (for CEA LIST) xlepallec@lilo.org - Bug 558456 |
| * |
| *****************************************************************************/ |
| |
| package org.eclipse.papyrus.uml.diagram.clazz.lf.classtextualedition.mapping.js2java; |
| |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.transaction.RecordingCommand; |
| import org.eclipse.emf.transaction.TransactionalEditingDomain; |
| import org.eclipse.gmf.runtime.notation.View; |
| import org.eclipse.papyrus.infra.core.services.ServiceException; |
| import org.eclipse.papyrus.infra.emf.utils.ServiceUtilsForEObject; |
| import org.eclipse.papyrus.infra.gmfdiag.common.editpart.ResizeableListCompartmentEditPart; |
| import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.ClassAttributeCompartmentEditPart; |
| import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.ClassAttributeCompartmentEditPartCN; |
| import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.ClassOperationCompartmentEditPart; |
| import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.ClassOperationCompartmentEditPartCN; |
| import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.OperationForClassEditPart; |
| import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.PropertyForClassEditPart; |
| import org.eclipse.papyrus.uml.diagram.clazz.lf.classtextualedition.Activator; |
| import org.eclipse.papyrus.uml.diagram.clazz.lf.classtextualedition.mapping.jsonstructures.JsonUmlClass; |
| import org.eclipse.papyrus.uml.diagram.clazz.lf.classtextualedition.mapping.jsonstructures.JsonUmlOperation; |
| import org.eclipse.papyrus.uml.diagram.clazz.lf.classtextualedition.mapping.jsonstructures.JsonUmlProperty; |
| import org.eclipse.papyrus.uml.diagram.clazz.lf.classtextualedition.messages.Messages; |
| //import org.eclipse.papyrus.uml.diagram.clazz.edit.parts.ClassEditPart; |
| import org.eclipse.papyrus.uml.diagram.common.editparts.ClassEditPart; |
| import org.eclipse.uml2.uml.Operation; |
| import org.eclipse.uml2.uml.Property; |
| |
| /** |
| * This class aims at fulfilling the class edit part according to a textual |
| * definition of a class (UmlClass) with cascading actions for properties and |
| * operations.<BR> |
| * It has to add new properties/operations and removing previous existing ones |
| * that do not appear in the textual definition anymore. That's the reason there |
| * are a lot of java attributes: to memorize previous existing elements. |
| * |
| */ |
| public class JsonUmlClassToEditPart { |
| |
| private static final Activator LOGGER = Activator.getDefault(); |
| |
| private JsonUmlClass theClass; |
| private ClassEditPart editPart; |
| private org.eclipse.uml2.uml.Class papyrusUmlClass; |
| private TransactionalEditingDomain editingDomain; |
| private ResizeableListCompartmentEditPart attributeCompartment; |
| private ResizeableListCompartmentEditPart operationCompartment; |
| private Map<String, org.eclipse.uml2.uml.Property> properties; |
| private Map<String, PropertyForClassEditPart> propertyEditParts; |
| private Map<String, OperationForClassEditPart> operationEditParts; |
| private Map<String, org.eclipse.uml2.uml.Operation> operations; |
| |
| /** |
| * This constructor takes a textual definition (UmlClass) and a Papyrus Class |
| * (referenced by the class edit part).<BR> |
| * The constructor creates all the structures to remember the state of the class |
| * before the edition.<BR> |
| * Finally the constructor launches all the process: fetch previous existing |
| * element and the mapping (replacing/adding/removing). |
| * |
| * @param theClass |
| * textual definition. |
| * @param editPart |
| * a Papyrus Class (GEF-level) |
| */ |
| public JsonUmlClassToEditPart(JsonUmlClass theClass, ClassEditPart editPart) { |
| super(); |
| try { |
| this.editPart = editPart; |
| this.theClass = theClass; |
| this.properties = new HashMap<>(); |
| this.propertyEditParts = new HashMap<>(); |
| this.operations = new HashMap<>(); |
| this.operationEditParts = new HashMap<>(); |
| |
| fetchPapyrusUmlElements(); |
| updatePapyrusUmlClassAccordingTextualVersion(); |
| } catch (Exception ex) { |
| LOGGER.logError(ex.toString(), ex); |
| } |
| } |
| |
| /** |
| * Load all the elements of the Papyrus class (the update is not done yet). This |
| * method calls the other fetch methods. |
| */ |
| private void fetchPapyrusUmlElements() { |
| |
| if (this.editPart.getModel() instanceof View) { |
| |
| View model = View.class.cast(this.editPart.getModel()); |
| |
| if (model.getElement() instanceof org.eclipse.uml2.uml.Class) { |
| |
| this.papyrusUmlClass = org.eclipse.uml2.uml.Class.class.cast(model.getElement()); |
| |
| List<?> children = editPart.getChildren(); |
| for (Object child : children) { |
| if (child instanceof ClassAttributeCompartmentEditPart || child instanceof ClassAttributeCompartmentEditPartCN) { |
| this.attributeCompartment = ResizeableListCompartmentEditPart.class.cast(child); |
| fetchAllAttributes(); |
| } else if (child instanceof ClassOperationCompartmentEditPart || child instanceof ClassOperationCompartmentEditPartCN) { |
| this.operationCompartment = ResizeableListCompartmentEditPart.class.cast(child); |
| fetchAllOperations(); |
| } |
| } |
| |
| try { |
| this.editingDomain = ServiceUtilsForEObject.getInstance() |
| .getTransactionalEditingDomain(papyrusUmlClass); |
| } catch (ServiceException ex) { |
| LOGGER.logError(ex.toString(), ex); |
| } |
| } else { |
| LOGGER.logCastProblem("model.getElement()", org.eclipse.uml2.uml.Class.class); //$NON-NLS-1$ |
| } |
| } else { |
| LOGGER.logCastProblem("editPart.getModel()", View.class); //$NON-NLS-1$ |
| } |
| |
| } |
| |
| /** |
| * This methods create a global command encapsulating the commands for updating |
| * the name, the properties and the operations. It calls the process* methods. |
| */ |
| private void updatePapyrusUmlClassAccordingTextualVersion() { |
| |
| Command globalCommand = createGlobalCommand(); |
| if (!theClass.getName().equals(papyrusUmlClass.getName())) { |
| globalCommand = globalCommand.chain(commandForSettingName()); |
| } |
| globalCommand = processProperties(globalCommand); |
| globalCommand = processOperations(globalCommand); |
| |
| editingDomain.getCommandStack().execute(globalCommand); |
| |
| } |
| |
| /** |
| * This method creates an empty command that will be used to give a name to the |
| * global command. |
| * |
| * @return the empty/naming command. |
| */ |
| private RecordingCommand createGlobalCommand() { |
| |
| return new RecordingCommand(editingDomain, Messages.JsonUmlClassToEditPart_TextualEditionOf_TitleCommand + this.papyrusUmlClass.getName()) { |
| @Override |
| protected void doExecute() { |
| // no actions to perform |
| // it's just a command to give a name to the global command. |
| } |
| }; |
| } |
| |
| /** |
| * This method creates a command to updating/setting the name of the class. |
| * |
| * @return the naming command. |
| */ |
| private Command commandForSettingName() { |
| return new RecordingCommand(editingDomain, Messages.JsonUmlClassToEditPart_SetNameCommand_TitleCommand) { |
| @Override |
| protected void doExecute() { |
| papyrusUmlClass.setName(theClass.getName()); |
| } |
| }; |
| } |
| |
| /** |
| * This method call {@link JsonUmlClassToEditPart#fetchAttribute(Object)} for each |
| * attribute in the properties compartment. |
| */ |
| private void fetchAllAttributes() { |
| for (Object child : attributeCompartment.getChildren()) { |
| if (child instanceof PropertyForClassEditPart) { |
| fetchAttribute(PropertyForClassEditPart.class.cast(child)); |
| } |
| } |
| } |
| |
| /** |
| * This method call {@link JsonUmlClassToEditPart#fetchOperation(Object)} for each |
| * operation in the operations compartment. |
| */ |
| private void fetchAllOperations() { |
| for (Object child : operationCompartment.getChildren()) { |
| if (child instanceof OperationForClassEditPart) { |
| fetchOperation(OperationForClassEditPart.class.cast(child)); |
| } |
| } |
| } |
| |
| /** |
| * This method gets real property and its associated element (edit part and the |
| * notation element) and stores them in the corresponding maps. |
| * |
| * @param child |
| * the property edit part |
| */ |
| private void fetchAttribute(PropertyForClassEditPart propertyEditPart) { |
| if (propertyEditPart.getModel() instanceof View) { |
| View visualStuff = View.class.cast(propertyEditPart.getModel()); |
| if (visualStuff.getElement() instanceof Property) { |
| Property property = Property.class.cast(visualStuff.getElement()); |
| |
| this.propertyEditParts.put(property.getName(), propertyEditPart); |
| this.properties.put(property.getName(), property); |
| } else { |
| LOGGER.logCastProblem("visualStuff.getElement()", Property.class); //$NON-NLS-1$ |
| } |
| } else { |
| LOGGER.logCastProblem("propertyEditPart.getModel()", View.class); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * This method gets real operation and its associated element (edit part and the |
| * notation element) and stores them in the corresponding maps. |
| * |
| * @param child |
| * the operation edit part |
| */ |
| private void fetchOperation(OperationForClassEditPart operationEditPart) { |
| if (operationEditPart.getModel() instanceof View) { |
| View visualStuff = View.class.cast(operationEditPart.getModel()); |
| if (visualStuff.getElement() instanceof Operation) { |
| Operation operation = (Operation) visualStuff.getElement(); |
| |
| this.operationEditParts.put(operation.getName(), operationEditPart); |
| this.operations.put(operation.getName(), operation); |
| } else { |
| LOGGER.logCastProblem("visualStuff.getElement()", Operation.class); //$NON-NLS-1$ |
| } |
| } else { |
| LOGGER.logCastProblem("operationEditPart.getModel()", View.class); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Get the list of the real properties found in the class edit part. |
| * |
| * @return list of the real properties |
| */ |
| private Property[] getAllAttributes() { |
| return this.properties.values().toArray(new Property[0]); |
| } |
| |
| /** |
| * Get the list of the real operations found in the class edit part. |
| * |
| * @return list of the real operations |
| */ |
| private Operation[] getAllOperations() { |
| return this.operations.values().toArray(new Operation[0]); |
| } |
| |
| /** |
| * This method updates the properties.<BR> |
| * First, for each property in the textual definition of the class, it looks if |
| * a property in the papyrus class exists with the same name. If it is, it |
| * updates it and removes it from the list of properties to actually remove. If |
| * not, it creates a new property.<BR> |
| * Second, all the existing properties that have not been "met" are removed. |
| * |
| * @param globalCommand |
| * the global command on which all the properties edition |
| * commands will be chained with. |
| * @return the new global command. |
| */ |
| private Command processProperties(Command globalCommand) { |
| try { |
| |
| for (JsonUmlProperty property : theClass.getProperties()) { |
| Property papyrusProperty = properties.get(property.getName()); |
| if (papyrusProperty != null) { |
| globalCommand = globalCommand |
| .chain(ToEditPartFactory.getInstance().createJsonUmlPropertyToEditPart(editingDomain, editPart, attributeCompartment) |
| .commandForUpdatingProperty(property, papyrusProperty)); |
| |
| properties.remove(property.getName(), papyrusProperty); |
| } else { |
| globalCommand = globalCommand |
| .chain(ToEditPartFactory.getInstance().createJsonUmlPropertyToEditPart(editingDomain, editPart, attributeCompartment) |
| .commandForAddingProperty(property)); |
| } |
| } |
| for (Property papyrusProperty : getAllAttributes()) { |
| globalCommand = globalCommand |
| .chain(ToEditPartFactory.getInstance().createJsonUmlPropertyToEditPart(editingDomain, editPart, attributeCompartment) |
| .commandForRemovingProperty(propertyEditParts, papyrusProperty)); |
| } |
| } catch (Exception ex) { |
| LOGGER.logError(ex.toString(), ex); |
| } |
| return globalCommand; |
| } |
| |
| /** |
| * This method updates the operations.<BR> |
| * First, for each operation in the textual definition of the class, it looks if |
| * an operation in the papyrus class exists with the same name. If it is, it |
| * updates it and removes it from the list of properties to actually remove. If |
| * not, it creates a new operation.<BR> |
| * Second, all the existing operations that have not been "met" are removed. |
| * |
| * @param globalCommand |
| * the global command on which all the operations edition |
| * commands will be chained with. |
| * @return the new global command. |
| */ |
| private Command processOperations(Command globalCommand) { |
| try { |
| for (JsonUmlOperation operation : theClass.getOperations()) { |
| Operation papyrusOperation = operations.get(operation.getName()); |
| if (papyrusOperation != null) { |
| globalCommand = globalCommand |
| .chain(ToEditPartFactory.getInstance().createJsonUmlOperationToEditPart(editingDomain, editPart, operationCompartment) |
| .commandForUpdatingOperation(operation, papyrusOperation)); |
| operations.remove(operation.getName(), papyrusOperation); |
| } else { |
| globalCommand = globalCommand |
| .chain(ToEditPartFactory.getInstance().createJsonUmlOperationToEditPart(editingDomain, editPart, operationCompartment) |
| .commandForAddingOperation(operation)); |
| } |
| } |
| for (Operation papyrusOperation : getAllOperations()) { |
| globalCommand = globalCommand |
| .chain(ToEditPartFactory.getInstance().createJsonUmlOperationToEditPart(editingDomain, editPart, operationCompartment) |
| .commandForRemovingOperation(operationEditParts, papyrusOperation)); |
| } |
| } catch (Exception ex) { |
| LOGGER.logError(ex.toString(), ex); |
| } |
| return globalCommand; |
| } |
| |
| } |
