Merge branch 'main' into bugfix/fix-unit-tests

# Conflicts:
#	tools/bamm-cli/src/main/java/io/openmanufacturing/sds/BammCli.java

Author: RaMisess

.gitignore

@@ -144,6 +144,10 @@ build
 /core/sds-aspect-meta-model-legacy*/src
 /core/sds-aspect-meta-model-legacy*/target
 
+# Directories where classes are generated during unit tests
+core/sds-aspect-model-java-generator/src/test/java/io/openmanufacturing/test
+core/sds-aspect-model-jackson/src/main/java/io/openmanufacturing/test
+
 # jqwik
 .jqwik-database
 

core/sds-aspect-meta-model-java/src/main/java/io/openmanufacturing/sds/metamodel/Property.java

@@ -2,7 +2,7 @@
  * Copyright (c) 2021 Robert Bosch Manufacturing Solutions GmbH
  *
  * See the AUTHORS file(s) distributed with this work for additional
- * information regarding authorship. 
+ * information regarding authorship.
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -24,9 +24,9 @@
 public interface Property extends Base, IsDescribed {
 
    /**
-    * @return the {@link Characteristic} describing this Property.
+    * @return the {@link Characteristic} describing this Property. This can be empty when the Property is abstract.
     */
-   Characteristic getCharacteristic();
+   Optional<Characteristic> getCharacteristic();
 
    /**
     * @return an {@link Optional} which may contain an example value for the Property. The type of the value is
@@ -50,7 +50,8 @@ default boolean isOptional() {
     * @return a {@link boolean} which determines whether the Property is included in the runtime data of an Aspect.
     *       By default Properties are included in the runtime data.
     *
-    * @see <a href="https://openmanufacturingplatform.github.io/sds-bamm-aspect-meta-model/bamm-specification/snapshot/modeling-guidelines.html#declaring-enumerations">BAMM Aspect Meta Model
+    * @see
+    * <a href="https://openmanufacturingplatform.github.io/sds-bamm-aspect-meta-model/bamm-specification/snapshot/modeling-guidelines.html#declaring-enumerations">BAMM Aspect Meta Model
     *       Specification - Declaring Enumerations</a>
     * @since BAMM 1.0.0
     */
@@ -59,22 +60,40 @@ default boolean isNotInPayload() {
    }
 
    /**
-    * Returns the Property's unconstrained Characteristic
+    * Returns true if the Property is abstract
     *
-    * @return The Property's Characteristic without Constraints
+    * @return
     */
-   default Characteristic getEffectiveCharacteristic() {
-      Characteristic characteristic = getCharacteristic();
-      while ( characteristic instanceof Trait ) {
-         characteristic = ((Trait) characteristic).getBaseCharacteristic();
-      }
-      return characteristic;
+   default boolean isAbstract() {
+      return false;
+   }
+
+   /**
+    * Returns the Property's unconstrained Characteristic.
+    * This is undefined when the Property is abstract
+    *
+    * @return The Property's Characteristic without Constraints, or empty, if {@link #isAbstract()} is true
+    */
+   default Optional<Characteristic> getEffectiveCharacteristic() {
+      return getCharacteristic().map( characteristic -> {
+         while ( characteristic.is( Trait.class ) ) {
+            characteristic = characteristic.as( Trait.class ).getBaseCharacteristic();
+         }
+         return characteristic;
+      } );
    }
 
    /**
     * @return the type for the Property.
     */
    default Optional<Type> getDataType() {
-      return getEffectiveCharacteristic().getDataType();
+      return getEffectiveCharacteristic().flatMap( Characteristic::getDataType );
+   }
+
+   /**
+    * @return the Property that is extended by this Property, if present
+    */
+   default Optional<Property> getExtends() {
+      return Optional.empty();
    }
 }

core/sds-aspect-meta-model-java/src/main/java/io/openmanufacturing/sds/metamodel/impl/DefaultProperty.java

@@ -23,24 +23,30 @@
 import io.openmanufacturing.sds.metamodel.visitor.AspectVisitor;
 
 public class DefaultProperty extends BaseImpl implements Property {
-   private final Characteristic characteristic;
+   private final Optional<Characteristic> characteristic;
    private final Optional<ScalarValue> exampleValue;
    private final boolean optional;
    private final boolean notInPayload;
    private final Optional<String> payloadName;
+   private final boolean isAbstract;
+   private final Optional<Property> extends_;
 
    public DefaultProperty( final MetaModelBaseAttributes metaModelBaseAttributes,
-         final Characteristic characteristic,
+         final Optional<Characteristic> characteristic,
          final Optional<ScalarValue> exampleValue,
          final boolean optional,
          final boolean notInPayload,
-         final Optional<String> payloadName ) {
+         final Optional<String> payloadName,
+         final boolean isAbstract,
+         final Optional<Property> extends_ ) {
       super( metaModelBaseAttributes );
       this.characteristic = characteristic;
       this.exampleValue = exampleValue;
       this.optional = optional;
       this.notInPayload = notInPayload;
       this.payloadName = payloadName;
+      this.isAbstract = isAbstract;
+      this.extends_ = extends_;
    }
 
    /**
@@ -49,7 +55,7 @@ public DefaultProperty( final MetaModelBaseAttributes metaModelBaseAttributes,
     * @return the characteristic.
     */
    @Override
-   public Characteristic getCharacteristic() {
+   public Optional<Characteristic> getCharacteristic() {
       return characteristic;
    }
 
@@ -87,6 +93,16 @@ public String getPayloadName() {
       return payloadName.orElseGet( this::getName );
    }
 
+   @Override
+   public boolean isAbstract() {
+      return isAbstract;
+   }
+
+   @Override
+   public Optional<Property> getExtends() {
+      return extends_;
+   }
+
    /**
     * Accepts an Aspect visitor
     *
@@ -106,6 +122,8 @@ public String toString() {
             .add( "exampleValue=" + exampleValue )
             .add( "optional=" + optional )
             .add( "notInPayload=" + notInPayload )
+            .add( "isAbstract=" + isAbstract )
+            .add( "extends=" + extends_ )
             .toString();
    }
 
@@ -124,12 +142,14 @@ public boolean equals( final Object o ) {
       final DefaultProperty that = (DefaultProperty) o;
       return optional == that.optional &&
             notInPayload == that.notInPayload &&
+            isAbstract == that.isAbstract &&
             Objects.equals( characteristic, that.characteristic ) &&
-            Objects.equals( exampleValue, that.exampleValue );
+            Objects.equals( exampleValue, that.exampleValue ) &&
+            Objects.equals( extends_, that.extends_ );
    }
 
    @Override
    public int hashCode() {
-      return Objects.hash( super.hashCode(), characteristic, exampleValue, optional, notInPayload );
+      return Objects.hash( super.hashCode(), characteristic, exampleValue, optional, notInPayload, isAbstract, extends_ );
    }
 }

core/sds-aspect-meta-model-java/src/main/java/io/openmanufacturing/sds/metamodel/loader/AttributeValueRetriever.java

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2022 Robert Bosch Manufacturing Solutions GmbH
+ *
+ * See the AUTHORS file(s) distributed with this work for additional
+ * information regarding authorship.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+package io.openmanufacturing.sds.metamodel.loader;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.apache.jena.rdf.model.Property;
+import org.apache.jena.rdf.model.RDFList;
+import org.apache.jena.rdf.model.RDFNode;
+import org.apache.jena.rdf.model.Resource;
+import org.apache.jena.rdf.model.Statement;
+import org.apache.jena.rdf.model.StmtIterator;
+import org.apache.jena.vocabulary.RDF;
+
+import io.openmanufacturing.sds.aspectmodel.vocabulary.BAMM;
+
+/**
+ * This class provides utilities to retrieve attribute values from model elements, e.g., a bamm:Property's bamm:characteristic.
+ * It knows how to handle:
+ * <ul>
+ *   <li>optionality (e.g., bamm-c:upperBoundDefinition on a bamm-c:RangeConstraint is not mandatory)</li>
+ *   <li>n-ary attributes (e.g., bamm:preferredName and bamm:description can appear multiple times)</li>
+ *   <li>abstract Properties (i.e., a bnode with bamm:extends used as a Property)</li>
+ *   <li>Property references (i.e., a bnode with bamm:property used as a Property)</li>
+ * </ul>
+ */
+public class AttributeValueRetriever {
+   protected final BAMM bamm;
+
+   public AttributeValueRetriever( final BAMM bamm ) {
+      this.bamm = bamm;
+   }
+
+   /**
+    * Returns the value of an attribute on a model element (or its super elements)
+    *
+    * @param modelElement the model element
+    * @param attribute the given attribute
+    * @return the statement asserting the value
+    * @throws AspectLoadingException when the attribute is not present or is present multiple times, or if bamm:extends is used wrong
+    */
+   protected Statement attributeValue( final Resource modelElement, final Property attribute ) {
+      return optionalAttributeValue( modelElement, attribute ).orElseThrow(
+            () -> new AspectLoadingException( "Missing attribute " + attribute + " on " + modelElement ) );
+   }
+
+   /**
+    * Returns the optional value of an attribute on a model element (or its super elements)
+    *
+    * @param modelElement the model element
+    * @param attribute the given attribute
+    * @return the optional statement asserting the value
+    */
+   protected Optional<Statement> optionalAttributeValue( final Resource modelElement, final Property attribute ) {
+      return attributeValues( modelElement, attribute ).stream().sequential().findFirst();
+   }
+
+   private boolean isRdfList( final Resource resource ) {
+      return resource.isAnon() && (resource.hasProperty( RDF.rest ) || resource.equals( RDF.nil ));
+   }
+
+   /**
+    * Returns the values of n-ary attributes on a model element (or its super elements), or if a given attribute is an rdf:List, the list elements.
+    * The list will be ordered by precedence, e.g., if a Property is present on both the current element and it's superelement, the assertion on the
+    * current element will be on a lower list index.
+    * Duplicate attribute assertions are removed and only the assertion with the highest precedence will be returned (bottom-most in the inheritance tree),
+    * this includes multiple assertions for the same attribute with rdf:langString values with the same language tag. For example:
+    *
+    * :SuperEntity a bamm:AbstractEntity ;
+    *   bamm:description "I'm abstract"@en ;
+    *   bamm:description "Ich bin abstrakt"@de ;
+    *   bamm:properties () .
+    *
+    * :MyEntity a bamm:Entity ;
+    *   bamm:extends :SuperEntity ;
+    *   bamm:description "I'm concrete"@en ;
+    *   bamm:properties () .
+    *
+    * Here, attributeValues( :MyEntity, bamm:description ) will return:
+    *   List( Statement( :MyEntity bamm:description "I'm contrete"@en ),
+    *         Statement( :SuperEntity bamm:description "Ich bin abstrakt"@de ) )
+    *
+    * The attribute that is overridden with a new value takes precedence, the one that is not overridden is inherited.
+    *
+    * @param modelElement the model element
+    * @param attribute the given attribute
+    * @return the list of statements asserting values for the attribute
+    */
+   protected List<Statement> attributeValues( final Resource modelElement, final Property attribute ) {
+      // Attribute values defined directly on the resource go into the result
+      final List<Statement> result = new ArrayList<>();
+      for ( final StmtIterator iterator = modelElement.listProperties( attribute ); iterator.hasNext(); ) {
+         final Statement statement = iterator.next();
+         // If the value happens to be an rdf:List, unroll the list
+         if ( statement.getObject().isResource() && isRdfList( statement.getObject().asResource() ) ) {
+            statement.getObject().as( RDFList.class )
+                  .mapWith( listValue -> modelElement.getModel().createStatement( modelElement, attribute, listValue ) )
+                  .forEach( result::add );
+         } else {
+            result.add( statement );
+         }
+      }
+
+      // If the model element is a bnode with bamm:property given, it's a Property reference. Follow it to retrieve the sought-for attribute assertions.
+      final StmtIterator referenceIterator = modelElement.listProperties( bamm.property() );
+      if ( referenceIterator.hasNext() ) {
+         final RDFNode referencedElement = referenceIterator.next().getObject();
+         if ( !referencedElement.isResource() ) {
+            throw new AspectLoadingException( "bamm:property on " + modelElement + " must point to a Property" );
+         }
+         result.addAll( attributeValues( referencedElement.asResource(), attribute ) );
+         return result;
+      }
+
+      // If the model element is bamm:extends another element, retrieve attribute assertions from this supertype as well.
+      final StmtIterator extendsIterator = modelElement.listProperties( bamm._extends() );
+      if ( extendsIterator.hasNext() ) {
+         final RDFNode superElementNode = extendsIterator.next().getObject();
+         if ( !superElementNode.isResource() ) {
+            throw new AspectLoadingException( "bamm:extends on " + modelElement + " must point to a valid model element" );
+         }
+         result.addAll( attributeValues( superElementNode.asResource(), attribute ) );
+      }
+
+      // Filter duplicate assertions by precedence
+      final List<Statement> filteredResult = new ArrayList<>();
+      final Set<String> assertedLanguageTags = new HashSet<>();
+      for ( final Statement statement : result ) {
+         if ( statement.getObject().isLiteral() ) {
+            final String languageTag = statement.getObject().asLiteral().getLanguage();
+            if ( !languageTag.isEmpty() ) {
+               if ( assertedLanguageTags.contains( languageTag ) ) {
+                  continue;
+               }
+               assertedLanguageTags.add( languageTag );
+            }
+         }
+         filteredResult.add( statement );
+      }
+
+      return filteredResult;
+   }
+}