1 files changed, 167 insertions, 0 deletions

diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/xtend-gen/hu/bme/mit/inf/dslreasoner/application/validation/MetamodelValidator.java b/Application/hu.bme.mit.inf.dslreasoner.application/xtend-gen/hu/bme/mit/inf/dslreasoner/application/validation/MetamodelValidator.java
new file mode 100644
index 00000000..44d86022
--- /dev/null
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/xtend-gen/hu/bme/mit/inf/dslreasoner/application/validation/MetamodelValidator.java
@@ -0,0 +1,167 @@
+package hu.bme.mit.inf.dslreasoner.application.validation;

+

+import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor;

+import java.util.Collections;

+import java.util.LinkedList;

+import java.util.List;

+import org.eclipse.emf.common.util.EList;

+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.EReference;

+import org.eclipse.emf.ecore.EcorePackage;

+import org.eclipse.xtend2.lib.StringConcatenation;

+import org.eclipse.xtext.xbase.lib.CollectionLiterals;

+import org.eclipse.xtext.xbase.lib.Extension;

+

+@SuppressWarnings("all")

+public class MetamodelValidator {

+  public LinkedList<String> validateMetamodel(final EcoreMetamodelDescriptor descriptor) {

+    final LinkedList<String> errors = new LinkedList<String>();

+    List<EClass> _classes = descriptor.getClasses();

+    this.allSupertypesAreIncluded(_classes, errors);

+    List<EEnum> _enums = descriptor.getEnums();

+    List<EEnumLiteral> _literals = descriptor.getLiterals();

+    this.allEnumTypesareIncluded(_enums, _literals, errors);

+    List<EClass> _classes_1 = descriptor.getClasses();

+    List<EReference> _references = descriptor.getReferences();

+    this.referenceEndpointsAreIncluded(_classes_1, _references, errors);

+    List<EClass> _classes_2 = descriptor.getClasses();

+    List<EAttribute> _attributes = descriptor.getAttributes();

+    this.attributeSourcePontIsIncluded(_classes_2, _attributes, errors);

+    List<EAttribute> _attributes_1 = descriptor.getAttributes();

+    this.attributeTargetIsSupported(_attributes_1, errors);

+    return errors;

+  }

+  

+  private boolean supportedEDataType(final EDataType dataType) {

+    @Extension

+    final EcorePackage l = EcorePackage.eINSTANCE;

+    EDataType _eInt = l.getEInt();

+    EDataType _eBoolean = l.getEBoolean();

+    EDataType _eString = l.getEString();

+    EDataType _eDouble = l.getEDouble();

+    EDataType _eFloat = l.getEFloat();

+    return Collections.<EDataType>unmodifiableList(CollectionLiterals.<EDataType>newArrayList(_eInt, _eBoolean, _eString, _eDouble, _eFloat)).contains(dataType);

+  }

+  

+  public void allSupertypesAreIncluded(final List<EClass> classes, final List<String> errors) {

+    for (final EClass c : classes) {

+      EList<EClass> _eSuperTypes = c.getESuperTypes();

+      for (final EClass s : _eSuperTypes) {

+        boolean _contains = classes.contains(s);

+        boolean _not = (!_contains);

+        if (_not) {

+          StringConcatenation _builder = new StringConcatenation();

+          _builder.append("Metamodel contains \"");

+          String _name = c.getName();

+          _builder.append(_name, "");

+          _builder.append("\" but not contains its supertype \"");

+          String _name_1 = s.getName();

+          _builder.append(_name_1, "");

+          _builder.append("\"!");

+          errors.add(_builder.toString());

+        }

+      }

+    }

+  }

+  

+  public void allEnumTypesareIncluded(final List<EEnum> enums, final List<EEnumLiteral> literals, final List<String> errors) {

+    for (final EEnumLiteral l : literals) {

+      EEnum _eEnum = l.getEEnum();

+      boolean _contains = enums.contains(_eEnum);

+      boolean _not = (!_contains);

+      if (_not) {

+        StringConcatenation _builder = new StringConcatenation();

+        _builder.append("Metamodel contains literal \"");

+        String _name = l.getName();

+        _builder.append(_name, "");

+        _builder.append("\" but does not contains enum \"");

+        EEnum _eEnum_1 = l.getEEnum();

+        String _name_1 = _eEnum_1.getName();

+        _builder.append(_name_1, "");

+        _builder.append("\"!");

+        errors.add(_builder.toString());

+      }

+    }

+  }

+  

+  public void referenceEndpointsAreIncluded(final List<EClass> classes, final List<EReference> references, final List<String> errors) {

+    for (final EReference reference : references) {

+      {

+        final EClass src = reference.getEContainingClass();

+        boolean _contains = classes.contains(src);

+        boolean _not = (!_contains);

+        if (_not) {

+          StringConcatenation _builder = new StringConcatenation();

+          _builder.append("Metamodel contains reference \"");

+          String _name = reference.getName();

+          _builder.append(_name, "");

+          _builder.append("\" but does not contains its source type \"");

+          String _name_1 = src.getName();

+          _builder.append(_name_1, "");

+          _builder.append("\"!");

+          errors.add(_builder.toString());

+        }

+        final EClass trg = reference.getEReferenceType();

+        boolean _contains_1 = classes.contains(trg);

+        boolean _not_1 = (!_contains_1);

+        if (_not_1) {

+          StringConcatenation _builder_1 = new StringConcatenation();

+          _builder_1.append("Metamodel contains reference \"");

+          String _name_2 = reference.getName();

+          _builder_1.append(_name_2, "");

+          _builder_1.append("\" but does not contains its target type \"");

+          String _name_3 = trg.getName();

+          _builder_1.append(_name_3, "");

+          _builder_1.append("\"!");

+          errors.add(_builder_1.toString());

+        }

+      }

+    }

+  }

+  

+  public void attributeSourcePontIsIncluded(final List<EClass> classes, final List<EAttribute> attributes, final List<String> errors) {

+    for (final EAttribute attribute : attributes) {

+      {

+        final Class<?> src = attribute.getContainerClass();

+        boolean _contains = classes.contains(src);

+        boolean _not = (!_contains);

+        if (_not) {

+          StringConcatenation _builder = new StringConcatenation();

+          _builder.append("Metamodel contains attribute \"");

+          String _name = attribute.getName();

+          _builder.append(_name, "");

+          _builder.append("\" but does not contains its source type \"");

+          String _name_1 = src.getName();

+          _builder.append(_name_1, "");

+          _builder.append("\"!");

+          errors.add(_builder.toString());

+        }

+      }

+    }

+  }

+  

+  public void attributeTargetIsSupported(final List<EAttribute> attributes, final List<String> errors) {

+    for (final EAttribute attribute : attributes) {

+      {

+        final EDataType trg = attribute.getEAttributeType();

+        boolean _supportedEDataType = this.supportedEDataType(trg);

+        boolean _not = (!_supportedEDataType);

+        if (_not) {

+          StringConcatenation _builder = new StringConcatenation();

+          _builder.append("Metamodels contains attribute \"");

+          String _name = attribute.getName();

+          _builder.append(_name, "");

+          _builder.append("\" with unsupported type \"");

+          String _name_1 = trg.getName();

+          _builder.append(_name_1, "");

+          _builder.append("\"!");

+          errors.add(_builder.toString());

+        }

+      }

+    }

+  }

+}