diff options
Diffstat (limited to 'sandbox/pasteInNewTable/org.eclipse.papyrus.uml.tools.utils/src/org/eclipse/papyrus/uml/tools/utils/UMLStringValueConverter.java')
| -rw-r--r-- | sandbox/pasteInNewTable/org.eclipse.papyrus.uml.tools.utils/src/org/eclipse/papyrus/uml/tools/utils/UMLStringValueConverter.java | 250 |
1 files changed, 250 insertions, 0 deletions
diff --git a/sandbox/pasteInNewTable/org.eclipse.papyrus.uml.tools.utils/src/org/eclipse/papyrus/uml/tools/utils/UMLStringValueConverter.java b/sandbox/pasteInNewTable/org.eclipse.papyrus.uml.tools.utils/src/org/eclipse/papyrus/uml/tools/utils/UMLStringValueConverter.java new file mode 100644 index 00000000000..b5260edbc3e --- /dev/null +++ b/sandbox/pasteInNewTable/org.eclipse.papyrus.uml.tools.utils/src/org/eclipse/papyrus/uml/tools/utils/UMLStringValueConverter.java @@ -0,0 +1,250 @@ +/*****************************************************************************
+ * Copyright (c) 2013 CEA LIST.
+ *
+ *
+ * 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:
+ * Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
+ *
+ *****************************************************************************/
+package org.eclipse.papyrus.uml.tools.utils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EcorePackage;
+import org.eclipse.osgi.util.NLS;
+import org.eclipse.papyrus.infra.emf.Activator;
+import org.eclipse.papyrus.infra.emf.utils.EMFStringValueConverter;
+import org.eclipse.papyrus.infra.emf.utils.MultiConvertedValueContainer;
+import org.eclipse.papyrus.infra.emf.utils.ConvertedValueContainer;
+import org.eclipse.papyrus.infra.emf.utils.StringValueConverterStatus;
+import org.eclipse.uml2.uml.DataType;
+import org.eclipse.uml2.uml.Enumeration;
+import org.eclipse.uml2.uml.EnumerationLiteral;
+import org.eclipse.uml2.uml.NamedElement;
+import org.eclipse.uml2.uml.Namespace;
+import org.eclipse.uml2.uml.PrimitiveType;
+import org.eclipse.uml2.uml.Property;
+import org.eclipse.uml2.uml.Type;
+import org.eclipse.uml2.uml.UMLPackage;
+
+/**
+ * ULM String converter
+ * @author vl222926
+ *
+ */
+public class UMLStringValueConverter extends EMFStringValueConverter {
+
+ final protected Map<EClass, NameResolutionHelper> nameResolutionHelpers = new HashMap<EClass, NameResolutionHelper>();
+
+ private static final String THE_ENUMERATION_LITERAL_X_CANT_BE_FOUND = "The enumeration literal {0} can't be found";
+
+ private static final String SOME_STRING_CANT_BE_RESOLVED_TO_FIND_X = "Some String can't be resolved to find {0}";
+
+ private static final String NO_X_REPRESENTED_BY_Y_HAVE_BEEN_FOUND = "No {0} represented by {1} have been found";
+
+ /**
+ *
+ * Constructor.
+ *
+ * @param context
+ * the context used to resolve the value
+ * @param multiValueSeparator
+ * the string used to seprate values
+ */
+ public UMLStringValueConverter(final Namespace context, final String multiValueSeparator) {
+ super(context, multiValueSeparator);
+ }
+
+ /**
+ *
+ * @see org.eclipse.papyrus.infra.emf.utils.EMFStringValueConverter#dispose()
+ *
+ */
+ @Override
+ public void dispose() {
+ super.dispose();
+ nameResolutionHelpers.clear();
+ }
+
+ @Override
+ protected int getFeatureUpperBound(Object feature) {
+ if(feature instanceof Property) {
+ return ((Property)feature).getUpper();
+ }
+ return super.getFeatureUpperBound(feature);
+ }
+
+ @Override
+ protected EClassifier getFeatureType(Object feature) {
+ final EClassifier featureType;
+ if(feature instanceof Property) {
+ final Type type = ((Property)feature).getType();
+ if(type instanceof PrimitiveType) {
+ final PrimitiveType pType = (PrimitiveType)type;
+ final String name = pType.getName();
+ if(PrimitivesTypesUtils.UML_BOOLEAN.equals(name)) {
+ featureType = EcorePackage.eINSTANCE.getEBoolean();
+ } else if(PrimitivesTypesUtils.UML_INTEGER.equals(name)) {
+ featureType = EcorePackage.eINSTANCE.getEInt();
+ } else if(PrimitivesTypesUtils.UML_REAL.equals(name)) {
+ featureType = EcorePackage.eINSTANCE.getEDouble();
+ } else if(PrimitivesTypesUtils.UML_STRING.equals(name)) {
+ featureType = EcorePackage.eINSTANCE.getEString();
+ } else if(PrimitivesTypesUtils.UML_UNLIMITED_NATURAL.equals(name)) {
+ featureType = EcorePackage.eINSTANCE.getEInt();
+ } else { //custom PrimitiveType
+ featureType = EcorePackage.eINSTANCE.getEString();
+ }
+ } else if(type instanceof Enumeration) {
+ featureType = UMLPackage.eINSTANCE.getEnumeration();
+ } else if(type instanceof DataType) {//FIXME manage the data type
+ featureType = EcorePackage.eINSTANCE.getEString();
+ } else {
+ featureType = type.eClass();
+ }
+ } else {
+ featureType = super.getFeatureType(feature);
+ }
+ return featureType;
+ }
+
+
+ @Override
+ public ConvertedValueContainer<?> deduceValueFromString(Object feature, String valueAsString) {
+ final EClassifier featureType = getFeatureType(feature);
+ if(feature instanceof Property) {
+ return deduceValueFromString(feature, featureType, valueAsString);
+ }
+ return super.deduceValueFromString(feature, valueAsString);
+ }
+ /**
+ *
+ * @see org.eclipse.papyrus.infra.emf.utils.EMFStringValueConverter#deduceValueFromString(java.lang.Object, org.eclipse.emf.ecore.EClassifier,
+ * java.lang.String)
+ *
+ * @param feature
+ * @param featureType
+ * @param valueAsString
+ * @return
+ */
+ @Override
+ protected ConvertedValueContainer<?> deduceValueFromString(Object feature, EClassifier featureType, String valueAsString) {
+ if(featureType instanceof EClass && feature instanceof Property) {
+ final int upperbound = getFeatureUpperBound(feature);
+ boolean isMany = (upperbound > 1 || upperbound == -1);
+ if(PrimitivesTypesUtils.ENUMERATION.equals(featureType.getName())) {
+ return deduceEnumerationLiteralValue(isMany, valueAsString, (Enumeration)((Property)feature).getType());
+ }
+ }
+ return super.deduceValueFromString(feature, featureType, valueAsString);
+ }
+
+
+ /**
+ *
+ * @see org.eclipse.papyrus.infra.emf.utils.EMFStringValueConverter#deduceEObjectValue(org.eclipse.emf.ecore.EObject, java.lang.Object,
+ * org.eclipse.emf.ecore.EClass, boolean, java.lang.String)
+ *
+ * @param resolutionContext
+ * @param feature
+ * @param featureType
+ * @param isMany
+ * @param valueAsString
+ * @return
+ * @throws StringValueSolverException
+ */
+ @Override
+ protected ConvertedValueContainer<?> deduceEObjectValue(EObject resolutionContext, Object feature, EClass eClass, boolean isMany, String valueAsString) {
+ if(valueAsString!=null && !valueAsString.isEmpty() && resolutionContext instanceof Namespace) {
+ IStatus iStatus = Status.OK_STATUS;
+ final Collection<String> unresolvedValues = new ArrayList<String>();
+ Namespace namespace = (Namespace)resolutionContext;
+ ConvertedValueContainer<?> returnedValue = null;
+ NameResolutionHelper helper = this.nameResolutionHelpers.get(eClass);
+ if(helper == null) {
+ helper = new NameResolutionHelper(namespace, eClass);
+ this.nameResolutionHelpers.put(eClass, helper);
+ }
+ if(isMany) {
+ final Collection<NamedElement> values = new HashSet<NamedElement>();
+ for(final String str : valueAsString.split(this.multiValueSeparator)) {
+ final List<NamedElement> elements = helper.getNamedElements(str);
+ if(elements.size() == 1) {
+ values.add(elements.get(0));
+ } else {
+ unresolvedValues.add(str);
+ }
+ if(!unresolvedValues.isEmpty()) {
+ iStatus = new StringValueConverterStatus(IStatus.ERROR, Activator.PLUGIN_ID, NLS.bind(SOME_STRING_CANT_BE_RESOLVED_TO_FIND_X, eClass.getName()), unresolvedValues);
+ }
+ returnedValue = new MultiConvertedValueContainer<NamedElement>(values, iStatus);
+ }
+ } else {
+ final List<NamedElement> elements = helper.getNamedElements(valueAsString);
+ if(elements.size() == 1) {
+ //it is OK
+ returnedValue = new ConvertedValueContainer<NamedElement>(elements.get(0), iStatus);
+ } else {
+ unresolvedValues.add(valueAsString);
+ iStatus = new StringValueConverterStatus(IStatus.ERROR, Activator.PLUGIN_ID, NLS.bind(NO_X_REPRESENTED_BY_Y_HAVE_BEEN_FOUND, eClass.getName(), valueAsString), unresolvedValues);
+ returnedValue = new ConvertedValueContainer<Boolean>(null, iStatus);
+ }
+ }
+ return returnedValue;
+ }
+ return super.deduceEObjectValue(resolutionContext, feature, eClass, isMany, valueAsString);
+ }
+
+ /**
+ *
+ * @param isMany
+ * <code>true</code> if the feature isMany
+ * @param valueAsString
+ * the value to parse
+ * @return
+ * the result of the parsing
+ */
+ protected ConvertedValueContainer<?> deduceEnumerationLiteralValue(final boolean isMany, final String valueAsString, final Enumeration enumeration) {
+ ConvertedValueContainer<?> returnedValue = null;
+ IStatus iStatus = Status.OK_STATUS;
+ final Collection<String> unresolvedValues = new ArrayList<String>();
+ if(isMany) {
+ final Collection<EnumerationLiteral> values = new ArrayList<EnumerationLiteral>();
+ for(final String str : valueAsString.split(this.multiValueSeparator)) {
+ final EnumerationLiteral lit = (EnumerationLiteral)enumeration.getMember(str);
+ if(lit != null) {
+ values.add(lit);
+ } else {
+ unresolvedValues.add(str);
+ }
+ }
+ if(!unresolvedValues.isEmpty()) {
+ iStatus = new StringValueConverterStatus(IStatus.ERROR, Activator.PLUGIN_ID, NLS.bind(SOME_STRING_ARE_NOT_VALID_TO_CREATE_X, PrimitivesTypesUtils.ENUMERATION_LITERAL), unresolvedValues);
+ }
+ returnedValue = new MultiConvertedValueContainer<EnumerationLiteral>(values, iStatus);
+ } else {
+ final EnumerationLiteral lit = (EnumerationLiteral)enumeration.getMember(valueAsString);
+ if(lit == null) {
+ unresolvedValues.add(valueAsString);
+ iStatus = new StringValueConverterStatus(IStatus.ERROR, Activator.PLUGIN_ID, NLS.bind(THE_ENUMERATION_LITERAL_X_CANT_BE_FOUND, valueAsString, PrimitivesTypesUtils.ENUMERATION_LITERAL), unresolvedValues);
+ }
+ returnedValue = new ConvertedValueContainer<EnumerationLiteral>(lit, iStatus);
+ }
+ return returnedValue;
+ }
+}
|