Refactor adapter to simplify it

Author: melaasar

build.gradle

@@ -1,6 +1,6 @@
 subprojects {
     group = 'io.opencaesar.adapters'
-    version = '2.10.0'
+    version = '2.11.0'
 
     ext.versions = [
         oml: '2.+',

ecore2oml-gradle/src/main/java/io/opencaesar/ecore2oml/Ecore2OmlTask.java

@@ -72,6 +72,15 @@ public Ecore2OmlTask() {
     @Input
     public abstract Property<String> getOutputFileExtension();
 
+    /**
+	 * The namespace Mappings
+	 * 
+	 * @return String List Property
+	 */
+    @Optional
+    @Input
+    public abstract ListProperty<String> getNamespaceMap();
+
     /**
 	 * The debug flag
 	 * 
@@ -110,6 +119,12 @@ public void run() {
         if (getOutputFileExtension().isPresent()) {
 		    args.add("-oe");
 		    args.add(getOutputFileExtension().get());
+        }
+        if (getNamespaceMap().isPresent()) {
+        	for (var ns : getNamespaceMap().get()) {
+    		    args.add("-ns");
+    		    args.add(ns);
+        	}
         }
 		if (getDebug().isPresent() && getDebug().get()) {
 		    args.add("-d");

ecore2oml/README.md

@@ -25,6 +25,7 @@ Args
 --referenced-ecore-path | -r path/to/referenced/ecore/file [Optional]
 --input-file-extension | -ie Extension of input file [Optional, ecore/xcore by default]
 --output-file-extension | -oe Extension of output file (Optional, oml by default, other options omlxmi and omljson)
+--namespace-map | -ns Mapping of old namespace prefix to new namespace prefix (Optional, syntax is oldNsPrefix=newNsPrefix)
 --debug | -d Shows debug statements
 --help | -h Shows help
 ```
@@ -45,5 +46,6 @@ task ecore2oml(type:io.opencaesar.ecore2oml.Ecore2OmlTask) {
 	referencedEcorePaths = [ file('path/to/options/file.json') ] // Optional
 	inputFileExtensions = ['ecore', 'xcore'] // Optional
 	outputFileExtension = 'oml' // Optional (other options, omlxmi or omljson)
+	namespaceMap = [ 'oldNsPrefix=newNsPrefix' ] // Optional
 }               
 ```

ecore2oml/src/main/java/io/opencaesar/ecore2oml/AssociationBuilder.java

@@ -22,9 +22,9 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.LinkedHashSet;
+import java.util.HashMap;
 import java.util.List;
-import java.util.Set;
+import java.util.Map;
 
 import org.apache.log4j.Appender;
 import org.apache.log4j.AppenderSkeleton;
@@ -63,58 +63,75 @@ public class Ecore2OmlApp {
 	private static final String ECORE = "ecore";
 	private static final String XCORE = "xcore";
 
-	@Parameter(
-		names= {"--input-folder-path","-i"}, 
-		description="Location of input Ecore folder (Required)",
-		validateWith=InputFolderPath.class, 
-		required=true, 
-		order=1)
-	private String inputFolderPath = null;
-
-	@Parameter(
-		names= {"--output-folder-path", "-o"}, 
-		description="Location of the output OML folder (Required)", 
-		validateWith=OutputFolderPath.class, 
-		required=true, 
-		order=2)
-	private String outputFolderPath;
-
-	@Parameter(
-		names= {"--referenced-ecore-path", "-r"}, 
-		description="Location of a referenced ecore file (Optional)", 
-		validateWith= InputEcorePath.class,
-		required=false, 
-		order=3
-	)
-	private List<String> referencedEcorePaths = new ArrayList<>();
+	static class Options {
+		@Parameter(
+			names= {"--input-folder-path","-i"}, 
+			description="Location of input Ecore folder (Required)",
+			validateWith=InputFolderPath.class, 
+			required=true)
+		public String inputFolderPath = null;
 
-	@Parameter(
-		names= {"--input-file-extension","-ie"}, 
-		description="Extension of input file (Optional, ecore/xcore by default)",
-		required=false, 
-		order=4)
-	private List<String> inputFileExtensions = Arrays.asList(ECORE, XCORE);
-
-	@Parameter(
-		names= {"--output-file-extension","-oe"}, 
-		description="Extension of output file (Optional, oml by default)",
-		required=false, 
-		order=5)
-	private String outputFileExtension = OmlConstants.OML_EXTENSION;
-
-	@Parameter(
-		names= {"--debug", "-d"}, 
-		description="Shows debug logging statements", 
-		order=6)
-	private boolean debug;
+		@Parameter(
+			names= {"--output-folder-path", "-o"}, 
+			description="Location of the output OML folder (Required)", 
+			validateWith=OutputFolderPath.class, 
+			required=true)
+		public String outputFolderPath;
+	
+		@Parameter(
+			names= {"--referenced-ecore-path", "-r"}, 
+			description="Location of a referenced ecore file (Optional)", 
+			validateWith= InputEcorePath.class,
+			required=false)
+		public List<String> referencedEcorePaths = new ArrayList<>();
+		
+		@Parameter(
+			names= {"--input-file-extension","-ie"}, 
+			description="Extension of input file (Optional, ecore/xcore by default)",
+			required=false)
+		public List<String> inputFileExtensions = Arrays.asList(ECORE, XCORE);
+	
+		@Parameter(
+			names= {"--output-file-extension","-oe"}, 
+			description="Extension of output file (Optional, oml by default)",
+			required=false)
+		public String outputFileExtension = OmlConstants.OML_EXTENSION;
+	
+		@Parameter(
+			names= {"--namespace-map","-ns"}, 
+			description="Mapping of existing namespace prefixes to new namespace prefixes (Optional, syntax is oldNsPrefix=newNsPrefix)",
+			validateWith= NamespaceMapping.class,
+			required=false)
+		public List<String> namespaceMap = Arrays.asList(new String[] {
+			"http://www.eclipse.org/emf/2002/Ecore#EObject=http://www.w3.org/2002/07/owl#Thing",
+			"http://www.eclipse.org/emf/2002/Ecore#EString=http://www.w3.org/2001/XMLSchema#string",
+			"http://www.eclipse.org/emf/2002/Ecore#EFloat=http://www.w3.org/2001/XMLSchema#float",
+			"http://www.eclipse.org/emf/2002/Ecore#EInt=http://www.w3.org/2001/XMLSchema#int",
+			"http://www.eclipse.org/emf/2002/Ecore#EBoolean=http://www.w3.org/2001/XMLSchema#boolean",
+			"http://www.eclipse.org/emf/2003/XMLType#ID=http://www.w3.org/2001/XMLSchema#string",
+			"http://www.eclipse.org/emf/2003/XMLType#QName=http://www.w3.org/2001/XMLSchema#string",
+			"http://www.eclipse.org/emf/2003/XMLType#Int=http://www.w3.org/2001/XMLSchema#int"
+		});
 
-	@Parameter(
-		names= {"--help","-h"}, 
-		description="Displays summary of options", 
-		help=true, 
-		order=7) 
-	private boolean help;
+		/*
+		 * A map equivalent of namespaceMap
+		 */
+		public Map<String, String> namespaceMap2 = new HashMap<>();
 
+		@Parameter(
+			names= {"--debug", "-d"}, 
+			description="Shows debug logging statements")
+		public boolean debug;
+	
+		@Parameter(
+			names= {"--help","-h"}, 
+			description="Displays summary of options", 
+			help=true) 
+		public boolean help;
+	}
+	
+	private final Options options = new Options();
+	
 	private Logger LOGGER = LogManager.getLogger(Ecore2OmlApp.class);
 
     /**
@@ -124,19 +141,25 @@ public class Ecore2OmlApp {
      */
 	public static void main(String ... args) throws IOException {
 		final Ecore2OmlApp app = new Ecore2OmlApp();
-		final JCommander builder = JCommander.newBuilder().addObject(app).build();
+		final JCommander builder = JCommander.newBuilder().addObject(app.options).build();
 		builder.parse(args);
-		if (app.help) {
+		if (app.options.help) {
 			builder.usage();
 			return;
 		}
-		if (app.debug) {
+		if (app.options.debug) {
 			final Appender appender = LogManager.getRootLogger().getAppender("stdout");
 			((AppenderSkeleton)appender).setThreshold(Level.DEBUG);
 		}
-		if (app.inputFolderPath.endsWith(File.separator)) {
-			app.inputFolderPath = app.inputFolderPath.substring(0, app.inputFolderPath.length()-1);
+		if (app.options.inputFolderPath.endsWith(File.separator)) {
+			app.options.inputFolderPath = app.options.inputFolderPath.substring(0, app.options.inputFolderPath.length()-1);
 		}
+		app.options.namespaceMap.forEach(entry -> {
+			var parts = entry.split("=");
+			var oldNs = parts[0].trim();
+			var newNs = parts[1].trim();
+			app.options.namespaceMap2.put(oldNs, newNs);
+		});
 		app.run();
 	}
 
@@ -154,11 +177,11 @@ private void run() throws IOException {
 		LOGGER.info("                        S T A R T");
 		LOGGER.info("                      Ecore to Oml "+getAppVersion());
 		LOGGER.info("=================================================================");
-		LOGGER.info("Input Folder Path= " + inputFolderPath);
-		LOGGER.info("Output Folder Path= " + outputFolderPath);
+		LOGGER.info("Input Folder Path= " + options.inputFolderPath);
+		LOGGER.info("Output Folder Path= " + options.outputFolderPath);
 
-		final File inputFolder = new File(inputFolderPath);
-		final Collection<File> inputFiles = collectInputFiles(inputFolder, inputFileExtensions);
+		final File inputFolder = new File(options.inputFolderPath);
+		final Collection<File> inputFiles = collectInputFiles(inputFolder, options.inputFileExtensions);
 
 		final ResourceSet inputResourceSet = createInputResourceSet();
 
@@ -170,7 +193,7 @@ private void run() throws IOException {
 			LOGGER.info("Reading: "+inputURI);
 			inputResourceSet.getResource(inputURI, true);
 		}
-
+		
 		// load the Oml registries here after the input have been read
 		OmlStandaloneSetup.doSetup();
 		OmlXMIResourceFactory.register();
@@ -180,7 +203,7 @@ private void run() throws IOException {
 		outputResourceSet.getLoadOptions().put(OmlConstants.RESOLVE_IRI_USING_RESOURCE_SET, Boolean.TRUE);
 		outputResourceSet.eAdapters().add(new ECrossReferenceAdapter());
 
-		final File outputFolder = new File(outputFolderPath);		
+		//final File outputFolder = new File(options.outputFolderPath);		
 
 		// create the Oml builder
 		final OmlBuilder builder = new OmlBuilder(outputResourceSet);
@@ -189,29 +212,22 @@ private void run() throws IOException {
 		builder.start();
 
 		// convert the input resources
-		List<URI> outputResourceURIs = new ArrayList<>(); 
-		Set<URI> unconvertedResourceURIs= new LinkedHashSet<>(inputResourceURIs); 
-		while (!unconvertedResourceURIs.isEmpty()) {
-			List<URI> uris = new ArrayList<URI>(unconvertedResourceURIs);
-			for (URI uri : uris) {
-				Resource inputResource = inputResourceSet.getResource(uri, true);
-				Ecore2Oml e2o = new Ecore2Oml(inputFolder, inputResource, outputFolder, outputFileExtension, builder);
-				Set<URI> newURIs = e2o.run();
-				assert (!outputResourceURIs.removeAll(newURIs));
-				outputResourceURIs.addAll(newURIs);
-				unconvertedResourceURIs.addAll(e2o.getImportedURIs());
-			}
-			unconvertedResourceURIs.removeAll(uris);
+		for (URI uri : inputResourceURIs) {
+			Resource inputResource = inputResourceSet.getResource(uri, true);
+			Ecore2Oml e2o = new Ecore2Oml(inputResource, builder, options);
+			e2o.run();
 		}
-		
+
+		// get the output resources to save
+		List<Resource> outputResources = new ArrayList<>(builder.getResourceSet().getResources()); 
+
 		// finish the Oml builder
 		builder.finish();
 
 		// save the output resources here instead of calling builder.save in order to log
-		for (URI outputResourceURI : outputResourceURIs) {
-			if (outputResourceURI.fileExtension().equals("oml")) {
-				LOGGER.info("Saving: "+outputResourceURI);
-				final Resource outputResource = outputResourceSet.getResource(outputResourceURI, false);
+		for (Resource outputResource : outputResources) {
+			if (outputResource.getURI().fileExtension().equals("oml")) {
+				LOGGER.info("Saving: "+outputResource.getURI());
 				outputResource.save(Collections.EMPTY_MAP);
 			}
 		}
@@ -230,7 +246,7 @@ private ResourceSet createInputResourceSet() {
 
 		// load any referenced Ecore files
 	    EPackage.Registry packageRegistry = injector.getInstance(EPackage.Registry.class);
-		for (String path : referencedEcorePaths) {
+		for (String path : options.referencedEcorePaths) {
 			final URI inputURI = URI.createFileURI(path);
 			Resource inputResource = resourceSet.getResource(inputURI, true);
 			if (inputResource != null) {
@@ -340,4 +356,21 @@ public void validate(final String name, final String value) throws ParameterExce
 		}
 	}
 
+    /**
+     * A parameter validator for namespace mappings
+     */
+	public static class NamespaceMapping implements IParameterValidator {
+		/**
+		 * Creates a new NamespaceMapping object
+		 */
+		public NamespaceMapping() {
+		}
+		@Override
+		public void validate(final String name, final String value) throws ParameterException {
+			var parts = value.split("=");
+			if (parts.length != 2) {
+				throw new ParameterException((("Parameter " + name) + " does not follow the syntax oldNs=newNs"));
+			}
+		}
+	}
 }

ecore2oml/src/main/java/io/opencaesar/ecore2oml/Ecore2Oml.java

@@ -0,0 +1,317 @@
+package io.opencaesar.ecore2oml;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.eclipse.emf.ecore.EAnnotation;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.ENamedElement;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.resource.Resource;
+
+class EcoreUtilities {
+
+	// Ecore annotation namespaces
+	private static final String EXTENDED_META_DATA_IRI = "http:///org/eclipse/emf/ecore/util/ExtendedMetaData";
+	private static final String GEN_MODEL_IRI = "http://www.eclipse.org/emf/2002/GenModel";
+
+	// Ecore metamodel namespaces
+	private static final String Ecore_IRI = "http://www.eclipse.org/emf/2002/Ecore";
+	
+	public static String getExtendedMetadataProperty(ENamedElement object, String property) {
+		final EAnnotation annotation = object.getEAnnotation(EXTENDED_META_DATA_IRI);
+		return (annotation == null) ? null : annotation.getDetails().get(property);
+	}
+
+	public static String getGenModelProperty(ENamedElement object, String property) {
+		EAnnotation annotation = object.getEAnnotation(GEN_MODEL_IRI);
+		return (annotation == null) ? null : annotation.getDetails().get(property); 
+	}
+
+	public static String getEcoreProperty(String property) {
+		return getEcoreNamespace()+property;
+	}
+
+	public static String getEcoreNamespace() {
+		return Ecore_IRI+"#";
+	}
+
+	public static boolean isAbstract(EClass object) {
+		return (object.isAbstract() || object.isInterface()) && 
+				object.getESuperTypes().stream().allMatch(i -> isAbstract(i));
+	}
+
+	public static Set<EAttribute> getSuperEAttributes(EAttribute object) {
+		Set<EAttribute> superRefs = new LinkedHashSet<EAttribute>() ;
+		EAnnotation ann = object.getEAnnotation("subsets");
+		if (ann != null) {
+			for (EObject ref : ann.getReferences()) {
+				superRefs.add((EAttribute)ref);
+			}
+		}
+		ann = object.getEAnnotation("redefines");
+		if (ann != null) {
+			for (EObject ref : ann.getReferences()) {
+				superRefs.add((EAttribute)ref);
+			}
+		}
+		return superRefs;
+	}
+
+	public static Set<EReference> getSuperEReferences(EReference object) {
+		Set<EReference> superRefs = new LinkedHashSet<EReference>() ;
+		EAnnotation ann = object.getEAnnotation("subsets");
+		if (ann != null) {
+			for (EObject ref : ann.getReferences()) {
+				superRefs.add((EReference)ref);
+			}
+		}
+		ann = object.getEAnnotation("redefines");
+		if (ann != null) {
+			for (EObject ref : ann.getReferences()) {
+				superRefs.add((EReference)ref);
+			}
+		}
+		return superRefs;
+	}
+
+	public static Set<EStructuralFeature> getSuperEStructuralFeatures(EStructuralFeature object) {
+		Set<EStructuralFeature> supers = new LinkedHashSet<EStructuralFeature>() ;
+		if (object instanceof EAttribute) {
+			supers.addAll(getSuperEAttributes((EAttribute)object));
+		} else if (object instanceof EReference) {
+			supers.addAll(getSuperEReferences((EReference)object));
+		}
+		return supers;
+	}
+	
+	/**
+	 * ERelation Builder
+	 */
+	public static class ERelationBuilder {
+		
+		private Map<EReference, ERelation> eRelations = new LinkedHashMap<>();
+
+		private List<Set<ERelation>> eRelationGroups = new ArrayList<>();
+
+		public class ERelation {
+			public Set<ERelation> supers = new LinkedHashSet<>();
+			public Set<ERelation> subs = new LinkedHashSet<>();
+			public List<EReference> ends = new ArrayList<>();
+			public EReference forward;
+			public EReference reverse;
+			@Override
+			public String toString() {
+				Iterator<EReference> i = ends.iterator();
+				String name = (i.hasNext()) ? getRelationName(i.next()) + "_" : "";
+				name = name + ((i.hasNext()) ?  getRelationName(i.next()) + "_" : "");
+				name += "A";
+				return name;
+			}
+		}
+		
+		public ERelationBuilder() {
+		}
+		
+		public void build(Resource inputResource) {
+			// create eRelations
+			var i = inputResource.getAllContents();
+			while (i.hasNext()) {
+				EObject o = i.next();
+				if (o instanceof EClass) {
+					EClass c = (EClass)o;
+					for(EReference e : c.getEReferences()) {
+						getERelation(e);
+					}
+				}
+			}
+			// remove redundant eRelation super types
+			for (ERelation a : eRelations.values()) {
+				removeRedundantSupers(a);
+			}
+			// calculate disjoint eRelation groups
+			for (ERelation a : eRelations.values()) {
+				putInERelationGroup(a, null);
+			}
+			
+			// determine the forward ends consistently within each group 
+			for (Set<ERelation> g : eRelationGroups) {
+				fixOrderOfEndsInGroup(g);
+			}
+		}
+		
+		public ERelation get(EReference eRef) {
+			return eRelations.get(eRef);
+		}
+
+		private void removeRedundantSupers(ERelation a) {
+			Map<ERelation, Set<ERelation>> superMap = new LinkedHashMap<>();
+			a.supers.forEach(i -> superMap.put(i, getAllSupers(i)));
+			Set<ERelation> redundants = new LinkedHashSet<>();
+			Iterator<ERelation> i = a.supers.iterator();
+			while (i.hasNext()) {
+				ERelation superAss = i.next();
+				for (ERelation s : a.supers) {
+					if (superMap.get(s).contains(superAss)) {
+						redundants.add(superAss);
+					}
+				};
+			}
+			a.supers.removeAll(redundants);
+		}
+		
+		private Set<ERelation> getAllSupers(ERelation a) {
+			Set<ERelation> allSupers = new LinkedHashSet<>();
+			for (ERelation superAss : a.supers) {
+				allSupers.add(superAss);
+				allSupers.addAll(getAllSupers(superAss));
+			}
+			return allSupers;
+		}
+		
+		private ERelation getERelation(EReference e) {
+			if (!eRelations.containsKey(e)) {
+				ERelation a = new ERelation();
+				eRelations.put(e, a);
+				a.ends.add(e);
+				for (EReference superRef : getSuperEReferences(e)) {
+					ERelation superAss = getERelation(superRef);
+					a.supers.add(superAss);
+					superAss.subs.add(a);
+				}
+				if (e.getEOpposite() != null) {
+					EReference o = e.getEOpposite();
+					eRelations.put(o, a);
+					a.ends.add(o);
+					for (EReference superRef : getSuperEReferences(o)) {
+						ERelation superAss = getERelation(superRef);
+						a.supers.add(superAss);
+						superAss.subs.add(a);
+					}
+				}
+			}
+			return eRelations.get(e);
+		}
+		
+		private void putInERelationGroup(ERelation a, Set<ERelation> group) {
+			if (group == null) {
+				for (Set<ERelation> g : eRelationGroups) {
+					if (g.contains(a)) {
+						return;
+					}
+				}
+				group = new LinkedHashSet<>();
+				eRelationGroups.add(group);
+			}
+			if (!group.contains(a)) {
+				group.add(a);
+				for (ERelation s : a.supers) {
+					putInERelationGroup(s, group);
+				};
+				for (ERelation s : a.subs) {
+					putInERelationGroup(s, group);
+				};
+			}
+		}	
+		
+		private void fixOrderOfEndsInGroup(Set<ERelation> group) {
+			// find the root of inheritance
+			Set<ERelation> roots = group.stream()
+					.filter(a -> a.supers.isEmpty())
+					.collect(Collectors.toCollection(LinkedHashSet::new));
+			
+			// find the first clear forward from the roots
+			EReference forward = roots.stream()
+					.map(a -> a.ends.iterator())
+					.map(i -> getPreferredForward(i.next(), (i.hasNext()? i.next() : null)))
+					.filter(i -> i != null)
+					.findFirst()
+					.orElse(group.iterator().next().ends.iterator().next());
+			
+			//set the forwards consistently throughout the group
+			ERelation a = eRelations.get(forward);
+			a.forward = forward;
+			a.reverse = forward.getEOpposite();
+			a.subs.forEach(s -> setForwardSub(s, a));
+		}
+		
+		private void setForwardSub(ERelation ass, ERelation superAss) {
+			if (ass.forward == null && ass.reverse == null) {
+				Iterator<EReference> i = ass.ends.iterator();
+				EReference ref1 = i.next();
+				EReference ref2 = ref1.getEOpposite();
+				if ((ref1 != null && superAss.forward != null && getSuperEReferences(ref1).contains(superAss.forward)) ||
+					(ref2 != null && superAss.reverse != null && getSuperEReferences(ref2).contains(superAss.reverse))) {
+					ass.forward = ref1;
+					ass.reverse = ref1.getEOpposite();
+				} else {
+					ass.forward = ref1.getEOpposite();
+					ass.reverse = ref1;
+				}
+				ass.subs.forEach(s -> setForwardSub(s, ass));
+				ass.supers.forEach(s -> setForwardSuper(s, ass));
+			}
+		}
+		
+		private void setForwardSuper(ERelation ass, ERelation subAss) {
+			if (ass.forward == null && ass.reverse == null) {
+				Iterator<EReference> i = ass.ends.iterator();
+				EReference ref1 = i.next();
+				EReference ref2 = ref1.getEOpposite();
+				if ((ref1 != null && subAss.forward != null && getSuperEReferences(subAss.forward).contains(ref1)) ||
+					(ref2 != null && subAss.reverse != null && getSuperEReferences(subAss.reverse).contains(ref2))) {
+					ass.forward = ref1;
+					ass.reverse = ref1.getEOpposite();
+				} else {
+					ass.forward = ref1.getEOpposite();
+					ass.reverse = ref1;
+				}
+				ass.subs.forEach(s -> setForwardSub(s, ass));
+				ass.supers.forEach(s -> setForwardSuper(s, ass));
+			}
+		}
+
+		private EReference getPreferredForward(EReference ref1, EReference ref2) {
+			EReference one = null;
+			if (ref2 == null) {
+				one = ref1;
+			} else {
+				// container wins
+				if (ref1.isContainment() && !ref2.isContainment()) {
+					one = ref1;
+				} else if (ref2.isContainment() && !ref1.isContainment()) {
+					one = ref2;
+				}
+				// higher multiplicity wins
+				if (one == null) {
+					int ref1Upper = (ref1.getUpperBound() == -1) ? Integer.MAX_VALUE : ref1.getUpperBound();
+					int ref2Upper = (ref2.getUpperBound() == -1) ? Integer.MAX_VALUE : ref2.getUpperBound();
+					if (ref1Upper > ref2Upper) {
+						one = ref1;
+					} else if (ref2Upper > ref1Upper) {
+						one = ref2;
+					}
+				}
+				// higher alphabetical wins
+				//if (one == null) {
+					//one = ref1.getName().compareTo(ref2.getName()) > 0 ? ref1 : ref2;
+				//}
+			}
+			assert (one == null);
+			return one;
+		}
+		
+		private String getRelationName(EReference object) {
+			return object.getEContainingClass().getName() + "_"  + object.getName();
+		}
+	}
+}