Fixed issue with generating java code for entities extend non-abstract entities.

#258

Author: ysrbo

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/AbstractEntity.java

@@ -13,23 +13,13 @@
 
 package org.eclipse.esmf.metamodel;
 
-import java.util.Collections;
-import java.util.List;
-
 /**
  * Represents a generic domain specific concept which may have multiple specific variants.
  *
  * @since SAMM 2.0.0
  */
 public interface AbstractEntity extends ComplexType {
 
-   /**
-    * @return a {@link java.util.List} of {@link ComplexType}s which extend this Abstract Entity
-    */
-   default List<ComplexType> getExtendingElements() {
-      return Collections.emptyList();
-   }
-
    @Override
    default boolean isAbstractEntity() {
       return true;

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/ComplexType.java

@@ -14,6 +14,7 @@
 package org.eclipse.esmf.metamodel;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -24,6 +25,13 @@
  */
 public interface ComplexType extends Type, StructureElement {
 
+   /**
+    * @return a {@link java.util.List} of {@link ComplexType}s which extend this Entity
+    */
+   default List<ComplexType> getExtendingElements() {
+      return Collections.emptyList();
+   }
+
    default boolean isAbstractEntity() {
       return false;
    }

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/impl/DefaultAbstractEntity.java

@@ -14,9 +14,7 @@
 package org.eclipse.esmf.metamodel.impl;
 
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 import org.eclipse.esmf.metamodel.AbstractEntity;
@@ -26,34 +24,19 @@
 import org.eclipse.esmf.metamodel.visitor.AspectVisitor;
 
 public class DefaultAbstractEntity extends DefaultComplexType implements AbstractEntity {
-
-   private final List<AspectModelUrn> extendingElements;
-
    public static DefaultAbstractEntity createDefaultAbstractEntity(
          final MetaModelBaseAttributes metaModelBaseAttributes,
          final List<? extends Property> properties,
          final Optional<ComplexType> _extends,
          final List<AspectModelUrn> extendingElements ) {
-      final DefaultAbstractEntity defaultAbstractEntity = new DefaultAbstractEntity( metaModelBaseAttributes, properties, _extends, extendingElements );
-      instances.put( metaModelBaseAttributes.getUrn().get(), defaultAbstractEntity );
-      return defaultAbstractEntity;
+      return new DefaultAbstractEntity( metaModelBaseAttributes, properties, _extends, extendingElements );
    }
 
-   private DefaultAbstractEntity( final MetaModelBaseAttributes metaModelBaseAttributes,
+   public DefaultAbstractEntity( final MetaModelBaseAttributes metaModelBaseAttributes,
          final List<? extends Property> properties,
          final Optional<ComplexType> _extends,
          final List<AspectModelUrn> extendingElements ) {
-      super( metaModelBaseAttributes, properties, _extends );
-      this.extendingElements = extendingElements;
-   }
-
-   /**
-    * @return all {@link ComplexType} instances from the {@link DefaultComplexType#instances} Map which extend this
-    *       Abstract Entity.
-    */
-   @Override
-   public List<ComplexType> getExtendingElements() {
-      return extendingElements.stream().map( instances::get ).filter( Objects::nonNull ).collect( Collectors.toList() );
+      super( metaModelBaseAttributes, properties, _extends, extendingElements );
    }
 
    /**

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/impl/DefaultComplexType.java

@@ -17,8 +17,10 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.WeakHashMap;
+import java.util.stream.Collectors;
 
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 import org.eclipse.esmf.metamodel.Aspect;
@@ -33,23 +35,23 @@ public class DefaultComplexType extends ModelElementImpl implements ComplexType
     * Used to keep track of all {@link ComplexType} instances regardles of whether they are directly or indirectly
     * referenced in the {@link Aspect}.
     */
-   protected static WeakHashMap<AspectModelUrn, ComplexType> instances = new WeakHashMap<>();
+   private static final WeakHashMap<AspectModelUrn, ComplexType> instances = new WeakHashMap<>();
 
    private final List<Property> properties;
    private final Optional<ComplexType> _extends;
+   private final List<AspectModelUrn> extendingElements;
 
-   protected static DefaultComplexType createDefaultComplexType( final MetaModelBaseAttributes metaModelBaseAttributes,
-         final List<? extends Property> properties, final Optional<ComplexType> _extends ) {
-      final DefaultComplexType defaultComplexType = new DefaultComplexType( metaModelBaseAttributes, properties, _extends );
-      instances.put( metaModelBaseAttributes.getUrn().get(), defaultComplexType );
-      return defaultComplexType;
-   }
-
-   protected DefaultComplexType( final MetaModelBaseAttributes metaModelBaseAttributes, final List<? extends Property> properties,
-         final Optional<ComplexType> _extends ) {
+   protected DefaultComplexType(
+         final MetaModelBaseAttributes metaModelBaseAttributes,
+         final List<? extends Property> properties,
+         final Optional<ComplexType> _extends,
+         final List<AspectModelUrn> extendingElements ) {
       super( metaModelBaseAttributes );
+      //noinspection OptionalGetWithoutIsPresent
+      instances.put( metaModelBaseAttributes.getUrn().get(), this );
       this.properties = new ArrayList<>( properties );
       this._extends = _extends;
+      this.extendingElements = extendingElements;
    }
 
    /**
@@ -67,6 +69,15 @@ public Optional<ComplexType> getExtends() {
       return _extends;
    }
 
+   /**
+    * @return all {@link ComplexType} instances from the {@link DefaultComplexType#instances} Map which extend this
+    *       Abstract Entity.
+    */
+   @Override
+   public List<ComplexType> getExtendingElements() {
+      return extendingElements.stream().map( instances::get ).filter( Objects::nonNull ).collect( Collectors.toList() );
+   }
+
    public static Map<AspectModelUrn, ComplexType> getInstances() {
       return Collections.unmodifiableMap( instances );
    }

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/impl/DefaultEntity.java

@@ -12,9 +12,11 @@
  */
 package org.eclipse.esmf.metamodel.impl;
 
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
+import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 import org.eclipse.esmf.metamodel.ComplexType;
 import org.eclipse.esmf.metamodel.Entity;
 import org.eclipse.esmf.metamodel.Property;
@@ -25,15 +27,21 @@ public class DefaultEntity extends DefaultComplexType implements Entity {
 
    public static DefaultEntity createDefaultEntity( final MetaModelBaseAttributes metaModelBaseAttributes,
          final List<? extends Property> properties, final Optional<ComplexType> _extends ) {
-      final DefaultEntity defaultEntity = new DefaultEntity( metaModelBaseAttributes, properties, _extends );
-      instances.put( metaModelBaseAttributes.getUrn().get(), defaultEntity );
-      return defaultEntity;
+      return new DefaultEntity( metaModelBaseAttributes, properties, _extends, Collections.emptyList() );
    }
 
-   private DefaultEntity( final MetaModelBaseAttributes metaModelBaseAttributes,
+   public DefaultEntity(
+         final MetaModelBaseAttributes metaModelBaseAttributes,
+         final List<? extends Property> properties ) {
+      this( metaModelBaseAttributes, properties, Optional.empty(), Collections.emptyList() );
+   }
+
+   public DefaultEntity(
+         final MetaModelBaseAttributes metaModelBaseAttributes,
          final List<? extends Property> properties,
-         final Optional<ComplexType> _extends ) {
-      super( metaModelBaseAttributes, properties, _extends );
+         final Optional<ComplexType> _extends,
+         final List<AspectModelUrn> extendingElements ) {
+      super( metaModelBaseAttributes, properties, _extends, extendingElements );
    }
 
    /**

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/metamodel/loader/instantiator/AbstractEntityInstantiator.java

@@ -13,86 +13,33 @@
 
 package org.eclipse.esmf.metamodel.loader.instantiator;
 
-import java.util.*;
-
-import org.apache.jena.rdf.model.Resource;
-import org.apache.jena.rdf.model.Statement;
-import org.apache.jena.vocabulary.RDF;
+import java.util.List;
+import java.util.Optional;
 
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
-import org.eclipse.esmf.characteristic.Collection;
 import org.eclipse.esmf.metamodel.AbstractEntity;
 import org.eclipse.esmf.metamodel.ComplexType;
-import org.eclipse.esmf.metamodel.Entity;
-import org.eclipse.esmf.metamodel.Aspect;
 import org.eclipse.esmf.metamodel.Property;
 import org.eclipse.esmf.metamodel.impl.DefaultAbstractEntity;
-import org.eclipse.esmf.metamodel.impl.DefaultComplexType;
-import org.eclipse.esmf.metamodel.loader.Instantiator;
 import org.eclipse.esmf.metamodel.loader.MetaModelBaseAttributes;
 import org.eclipse.esmf.metamodel.loader.ModelElementFactory;
 
-public class AbstractEntityInstantiator extends Instantiator<AbstractEntity> {
-
-   private final Set<Resource> processedExtendingElements = new HashSet<>();
-   private final Map<Resource, AbstractEntity> creatingElements = new HashMap<>();
+public class AbstractEntityInstantiator extends ComplexTypeInstantiator<AbstractEntity> {
 
    public AbstractEntityInstantiator( final ModelElementFactory modelElementFactory ) {
       super( modelElementFactory, AbstractEntity.class );
    }
 
-   /**
-    * Initializes a {@link DefaultAbstractEntity}.
-    * Since {@link ComplexType}s have a reference to the element which is extended by a particular {@link ComplexType},
-    * and the {@link AbstractEntity} has a list of references to all elements which extend the {@link AbstractEntity},
-    * a circular dependency exists between the {@link ComplexType} and the {@link AbstractEntity}.
-    *
-    * The reference between the {@link ComplexType}s represents the `extends` relationship between an {@link Entity} or
-    * an {@link AbstractEntity} and another {@link Entity} or {@link AbstractEntity}.
-    * The list of references between an {@link AbstractEntity} and all {@link ComplexType}s extending the
-    * {@link AbstractEntity} has been implemented to ensure that all extending {@link ComplexType}s are loaded into the
-    * {@link Aspect} whether they are directly linked to that Aspect or not. This
-    * scenario may occur for example when the Aspect Model contains a {@link Collection}
-    * with an {@link AbstractEntity} as its data type with multiple Entities extending the {@link AbstractEntity}.
-    *
-    * In order to prevent processing elements in this circular dependency more than once, causing an infinite loop,
-    * the elements which are processed are tracked in the {@link AbstractEntityInstantiator#processedExtendingElements}
-    * {@link Set}.
-    * Using the {@link DefaultComplexType#instances} Map to check whether an
-    * element has been processed does not work since the instance is only created once the `create` method of the
-    * corresponding {@link ComplexType} has been called. Creating the child elements however happens before this call.
-    */
    @Override
-   public AbstractEntity apply( final Resource abstractEntity ) {
-      if ( creatingElements.containsKey( abstractEntity ) )
-         return creatingElements.get( abstractEntity );
-      final MetaModelBaseAttributes metaModelBaseAttributes = buildBaseAttributes( abstractEntity );
-      final List<Property> properties = getPropertiesModels( abstractEntity, samm.properties() );
-
-      final Optional<ComplexType> extendedEntity = optionalAttributeValue( abstractEntity, samm._extends() ).map( Statement::getResource )
-            .map( extendedEntityResource -> attributeValue( extendedEntityResource, RDF.type ) ).map( entityStatement -> {
-               if ( samm.AbstractEntity().equals( entityStatement.getObject().asResource() ) ) {
-                  return modelElementFactory.create( AbstractEntity.class, entityStatement.getSubject() );
-               }
-               return modelElementFactory.create( Entity.class, entityStatement.getSubject() );
-            } );
-
-      final List<AspectModelUrn> extendingComplexTypes = new ArrayList<>();
-      DefaultAbstractEntity entity = DefaultAbstractEntity.createDefaultAbstractEntity( metaModelBaseAttributes, properties, extendedEntity,
+   protected AbstractEntity createDefaultEntity(
+         MetaModelBaseAttributes metaModelBaseAttributes,
+         List<Property> properties,
+         Optional<ComplexType> extendedEntity,
+         List<AspectModelUrn> extendingComplexTypes ) {
+      return new DefaultAbstractEntity(
+            metaModelBaseAttributes,
+            properties,
+            extendedEntity,
             extendingComplexTypes );
-      creatingElements.put( abstractEntity, entity );
-      extendingComplexTypes.addAll( model.listSubjectsWithProperty( samm._extends(), abstractEntity )
-            .mapWith( extendingComplexType -> attributeValue( extendingComplexType, RDF.type ) ).mapWith( statement -> {
-               if ( processedExtendingElements.contains( statement.getSubject() ) ) {
-                  return AspectModelUrn.fromUrn( statement.getSubject().getURI() );
-               }
-               processedExtendingElements.add( statement.getSubject() );
-               if ( samm.AbstractEntity().equals( statement.getObject().asResource() ) ) {
-                  return modelElementFactory.create( AbstractEntity.class, statement.getSubject() ).getAspectModelUrn().get();
-               }
-               return modelElementFactory.create( Entity.class, statement.getSubject() ).getAspectModelUrn().get();
-            } ).toList() );
-      creatingElements.remove( abstractEntity );
-      return entity;
    }
 }