1 files changed, 178 insertions, 0 deletions
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend
new file mode 100644
index 00000000..126dbb7d
--- /dev/null
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend
@@ -0,0 +1,178 @@
+package hu.bme.mit.inf.dslreasoner.application.execution
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassElement
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FeatureElement
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry
+import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification
+import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.LinkedList
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.EAttribute
+import org.eclipse.emf.ecore.EClass
+import org.eclipse.emf.ecore.EDataType
+import org.eclipse.emf.ecore.EEnum
+import org.eclipse.emf.ecore.EEnumLiteral
+import org.eclipse.emf.ecore.ENamedElement
+import org.eclipse.emf.ecore.EPackage
+import org.eclipse.emf.ecore.EReference
+import org.eclipse.emf.ecore.EcorePackage
+import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.emf.ecore.resource.ResourceSet
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
+import org.eclipse.xtend.lib.annotations.Data
+@Data
+class Metamodel {
+        List<EPackage> packages
+        EcoreMetamodelDescriptor descriptor
+} 
+class MetamodelLoader {
+        
+        def private static init() {
+                EcorePackage.eINSTANCE.EClass
+                Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("ecore",new XMIResourceFactoryImpl)
+        }
+        
+        public new() { init }
+        
+        def loadMetamodel(List<String> specification, ResourceSet rs, Context context) {
+                
+        }
+        
+        def loadMetamodel(MetamodelSpecification specification, ResourceSet rs, Context context) {
+                val Map<MetamodelEntry,List<EPackage>> entry2Packages = new HashMap
+                
+                for(entry : specification.entries) {
+                        val packagesInEntry = entry.path.path.loadPackageFromPath(rs,context)
+                        entry2Packages.put(entry,packagesInEntry)
+                }
+                
+                return entry2Packages
+        }
+        
+        public def pruneMetamodel(Map<MetamodelEntry,List<EPackage>> specification, ResourceSet rs, Context context) {
+                val List<EClass> classes = new LinkedList
+                val List<EEnum> enums = new LinkedList
+                val List<EEnumLiteral> literals = new LinkedList
+                val List<EReference> references = new LinkedList
+                val List<EAttribute> attributes = new LinkedList
+                
+                
+                /** Add all included types */
+                for(entry : specification.entrySet) {
+                        val metamodelEntry = entry.key
+                        val packages = entry.value
+                        
+                        /** Excluted types */
+                        val excludedTypeNames = metamodelEntry.excluding.filter(ClassElement).map[name].toSet
+                        /** Excluded features */
+                        val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet
+                        
+                        /** Load the types */
+                        for(package : packages) {
+                                for(class : package.EClassifiers.filter(EClass)) {
+                                        classes.addIfNotExcluded(class,excludedTypeNames)
+                                }
+                                for(enum : package.EClassifiers.filter(EEnum)) {
+                                        val added = enums.addIfNotExcluded(enum,excludedTypeNames)
+                                        if(added) {
+                                                for(literal : enum.ELiterals) {
+                                                        literals.addIfNotExcluded(literal,enum,excludedFeatureNames)
+                                                }
+                                        }
+                                }
+                        }
+                }
+                
+                /** Add all included references and attributes*/
+                for(entry : specification.entrySet) {
+                        val metamodelEntry = entry.key
+                        val packages = entry.value
+                        
+                        /** Excluded features */
+                        val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet
+                        
+                        /** See if type is included */
+                        for(package : packages) {
+                                for(class : package.EClassifiers.filter(EClass)) {
+                                        if(classes.contains(class)) {
+                                                for(reference : class.EReferences) {
+                                                        if(classes.contains(reference.EType)) {
+                                                                references.addIfNotExcluded(reference,class,excludedFeatureNames)
+                                                        }
+                                                }
+                                                for(attribute : class.EAttributes) {
+                                                        val type = attribute.EType
+                                                        if(type instanceof EEnum) {
+                                                                if(enums.contains(type)) {
+                                                                        attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
+                                                                } else if(type == EcorePackage.Literals) {
+                                                                        if(enums.contains(type)) {
+                                                                                attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
+                                                                        }
+                                                                }
+                                                        } else if(supportedEDataType(type as EDataType)) {
+                                                                attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
+        
+        private def supportedEDataType(EDataType dataType) {
+                val extension l = EcorePackage.eINSTANCE
+                return #[EInt, EBoolean, EString, EDouble, EFloat].contains(dataType)
+        }
+        
+        private def <T extends ENamedElement> addIfNotExcluded(
+                List<T> target,
+                T element,
+                Set<String> excluded)
+        {
+                if(excluded.contains(element.name)) {
+                        target += element
+                        return true
+                } else {
+                        return false
+                }
+        }
+        private def <T1 extends ENamedElement> addIfNotExcluded(
+                List<T1> target,
+                T1 element,
+                ENamedElement container,
+                Set<Pair<String,String>> excluded)
+        {
+                val pair = (container.name) -> (element.name)
+                
+                if(excluded.contains(pair)) {
+                        target += element
+                }
+        }
+        
+        private def List<EPackage> loadPackageFromPath(String path, ResourceSet rs, Context context) throws RuntimeException {
+                var Resource resource;
+                try{
+                        resource = rs.getResource(URI.createURI(path),true)
+                } catch(RuntimeException e) {
+                        context.writeError('''Unable to load EPackage: Error in path "«path»"!''')
+                        return #[]
+                }
+                val res = new ArrayList<EPackage>(resource.contents.size)
+                for(content: resource.contents) {
+                        if(content instanceof EPackage) {
+                                res += content
+                        } else {
+                                context.writeError('''Unable to load EPackage: The content of "«path»" is not an EPackage, but "«content.eClass.name»"!''')
+                        }
+                }
+                return res
+        }
+}
+\ No newline at end of file

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend new file mode 100644 index 00000000..126dbb7d --- /dev/null +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend
@@ -0,0 +1,178 @@
	1	package hu.bme.mit.inf.dslreasoner.application.execution
	2
	3	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassElement
	4	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FeatureElement
	5	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry
	6	import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification
	7	import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor
	8	import java.util.ArrayList
	9	import java.util.HashMap
	10	import java.util.LinkedList
	11	import java.util.List
	12	import java.util.Map
	13	import java.util.Set
	14	import org.eclipse.emf.common.util.URI
	15	import org.eclipse.emf.ecore.EAttribute
	16	import org.eclipse.emf.ecore.EClass
	17	import org.eclipse.emf.ecore.EDataType
	18	import org.eclipse.emf.ecore.EEnum
	19	import org.eclipse.emf.ecore.EEnumLiteral
	20	import org.eclipse.emf.ecore.ENamedElement
	21	import org.eclipse.emf.ecore.EPackage
	22	import org.eclipse.emf.ecore.EReference
	23	import org.eclipse.emf.ecore.EcorePackage
	24	import org.eclipse.emf.ecore.resource.Resource
	25	import org.eclipse.emf.ecore.resource.ResourceSet
	26	import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
	27	import org.eclipse.xtend.lib.annotations.Data
	28
	29	@Data
	30	class Metamodel {
	31	List<EPackage> packages
	32	EcoreMetamodelDescriptor descriptor
	33	}
	34
	35	class MetamodelLoader {
	36
	37	def private static init() {
	38	EcorePackage.eINSTANCE.EClass
	39	Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.put("ecore",new XMIResourceFactoryImpl)
	40	}
	41
	42	public new() { init }
	43
	44	def loadMetamodel(List<String> specification, ResourceSet rs, Context context) {
	45
	46	}
	47
	48	def loadMetamodel(MetamodelSpecification specification, ResourceSet rs, Context context) {
	49	val Map<MetamodelEntry,List<EPackage>> entry2Packages = new HashMap
	50
	51	for(entry : specification.entries) {
	52	val packagesInEntry = entry.path.path.loadPackageFromPath(rs,context)
	53	entry2Packages.put(entry,packagesInEntry)
	54	}
	55
	56	return entry2Packages
	57	}
	58
	59	public def pruneMetamodel(Map<MetamodelEntry,List<EPackage>> specification, ResourceSet rs, Context context) {
	60	val List<EClass> classes = new LinkedList
	61	val List<EEnum> enums = new LinkedList
	62	val List<EEnumLiteral> literals = new LinkedList
	63	val List<EReference> references = new LinkedList
	64	val List<EAttribute> attributes = new LinkedList
	65
	66
	67	/** Add all included types */
	68	for(entry : specification.entrySet) {
	69	val metamodelEntry = entry.key
	70	val packages = entry.value
	71
	72	/** Excluted types */
	73	val excludedTypeNames = metamodelEntry.excluding.filter(ClassElement).map[name].toSet
	74	/** Excluded features */
	75	val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet
	76
	77	/** Load the types */
	78	for(package : packages) {
	79	for(class : package.EClassifiers.filter(EClass)) {
	80	classes.addIfNotExcluded(class,excludedTypeNames)
	81	}
	82	for(enum : package.EClassifiers.filter(EEnum)) {
	83	val added = enums.addIfNotExcluded(enum,excludedTypeNames)
	84	if(added) {
	85	for(literal : enum.ELiterals) {
	86	literals.addIfNotExcluded(literal,enum,excludedFeatureNames)
	87	}
	88	}
	89	}
	90	}
	91	}
	92
	93	/** Add all included references and attributes*/
	94	for(entry : specification.entrySet) {
	95	val metamodelEntry = entry.key
	96	val packages = entry.value
	97
	98	/** Excluded features */
	99	val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet
	100
	101	/** See if type is included */
	102	for(package : packages) {
	103	for(class : package.EClassifiers.filter(EClass)) {
	104	if(classes.contains(class)) {
	105	for(reference : class.EReferences) {
	106	if(classes.contains(reference.EType)) {
	107	references.addIfNotExcluded(reference,class,excludedFeatureNames)
	108	}
	109	}
	110	for(attribute : class.EAttributes) {
	111	val type = attribute.EType
	112	if(type instanceof EEnum) {
	113	if(enums.contains(type)) {
	114	attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
	115	} else if(type == EcorePackage.Literals) {
	116	if(enums.contains(type)) {
	117	attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
	118	}
	119	}
	120	} else if(supportedEDataType(type as EDataType)) {
	121	attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
	122	}
	123	}
	124	}
	125	}
	126	}
	127	}
	128	}
	129
	130	private def supportedEDataType(EDataType dataType) {
	131	val extension l = EcorePackage.eINSTANCE
	132	return #[EInt, EBoolean, EString, EDouble, EFloat].contains(dataType)
	133	}
	134
	135	private def <T extends ENamedElement> addIfNotExcluded(
	136	List<T> target,
	137	T element,
	138	Set<String> excluded)
	139	{
	140	if(excluded.contains(element.name)) {
	141	target += element
	142	return true
	143	} else {
	144	return false
	145	}
	146	}
	147	private def <T1 extends ENamedElement> addIfNotExcluded(
	148	List<T1> target,
	149	T1 element,
	150	ENamedElement container,
	151	Set<Pair<String,String>> excluded)
	152	{
	153	val pair = (container.name) -> (element.name)
	154
	155	if(excluded.contains(pair)) {
	156	target += element
	157	}
	158	}
	159
	160	private def List<EPackage> loadPackageFromPath(String path, ResourceSet rs, Context context) throws RuntimeException {
	161	var Resource resource;
	162	try{
	163	resource = rs.getResource(URI.createURI(path),true)
	164	} catch(RuntimeException e) {
	165	context.writeError('''Unable to load EPackage: Error in path "«path»"!''')
	166	return #[]
	167	}
	168	val res = new ArrayList<EPackage>(resource.contents.size)
	169	for(content: resource.contents) {
	170	if(content instanceof EPackage) {
	171	res += content
	172	} else {
	173	context.writeError('''Unable to load EPackage: The content of "«path»" is not an EPackage, but "«content.eClass.name»"!''')
	174	}
	175	}
	176	return res
	177	}
	178	} \ No newline at end of file