Merge pull request #11 from admin-shell-io/feature/aml-deserializer

Feature/aml deserializer

Author: sebbader

dataformat-aml/pom.xml

@@ -33,6 +33,17 @@
             <artifactId>jaxb-api</artifactId>
             <version>${jaxb.version}</version>
         </dependency>
+        <dependency>
+            <groupId>xerces</groupId>
+            <artifactId>xercesImpl</artifactId>
+            <version>2.12.1</version>
+            <exclusions>
+				<exclusion>
+					<artifactId>xml-apis</artifactId>
+					<groupId>xml-apis</groupId>
+				</exclusion>
+			</exclusions>
+        </dependency>
         <dependency>
             <groupId>org.eclipse.persistence</groupId>
             <artifactId>org.eclipse.persistence.moxy</artifactId>
@@ -61,6 +72,11 @@
             <version>${xmlunit.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.inject</groupId>
+            <artifactId>guice</artifactId>
+            <version>5.0.1</version>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

dataformat-aml/src/main/java/io/adminshell/aas/v3/dataformat/aml/AmlDeserializer.java

@@ -17,6 +17,7 @@
 
 import io.adminshell.aas.v3.dataformat.DeserializationException;
 import io.adminshell.aas.v3.dataformat.Deserializer;
+import io.adminshell.aas.v3.dataformat.aml.deserialization.AasTypeFactory;
 import io.adminshell.aas.v3.dataformat.aml.deserialization.Aml2AasMapper;
 import io.adminshell.aas.v3.dataformat.aml.model.caex.CAEXFile;
 import io.adminshell.aas.v3.dataformat.mapping.MappingException;
@@ -34,14 +35,17 @@
 public class AmlDeserializer implements Deserializer {
 
     private static final Logger log = LoggerFactory.getLogger(AmlDeserializer.class);
+    private AasTypeFactory typeFactory = new AasTypeFactory();
 
     @Override
     public AssetAdministrationShellEnvironment read(String value) throws DeserializationException {
         try {
             Unmarshaller unmarshaller = JAXBContextFactory.createContext(new Class[]{CAEXFile.class}, null).createUnmarshaller();
             StringReader reader = new StringReader(value);
             CAEXFile aml = (CAEXFile) unmarshaller.unmarshal(reader);
-            Aml2AasMapper mapper = new Aml2AasMapper(new AmlDeserializationConfig.Builder().build());
+            Aml2AasMapper mapper = new Aml2AasMapper(new AmlDeserializationConfig.Builder()
+                    .typeFactory(typeFactory)
+                    .build());
             return mapper.map(aml);
         } catch (JAXBException ex) {
             throw new DeserializationException("error deserializing AssetAdministrationShellEnvironment", ex);
@@ -52,6 +56,6 @@ public AssetAdministrationShellEnvironment read(String value) throws Deserializa
 
     @Override
     public <T> void useImplementation(Class<T> aasInterface, Class<? extends T> implementation) {
-        throw new UnsupportedOperationException("Not supported yet.");
+        typeFactory.useImplementation(aasInterface, implementation);
     }
 }

dataformat-aml/src/main/java/io/adminshell/aas/v3/dataformat/aml/common/AbstractMappingContext.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2021 Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e. V.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.adminshell.aas.v3.dataformat.aml.common;
+
+import io.adminshell.aas.v3.dataformat.aml.serialization.naming.NamingStrategy;
+import io.adminshell.aas.v3.dataformat.mapping.Mapper;
+import io.adminshell.aas.v3.dataformat.mapping.MappingContext;
+import io.adminshell.aas.v3.dataformat.mapping.MappingProvider;
+import java.beans.PropertyDescriptor;
+
+/**
+ * Abstract base class for MappingContext used for mapping between AML and AAS
+ *
+ * @param <T>
+ */
+public class AbstractMappingContext<T extends Mapper> extends MappingContext<T> {
+
+    protected final NamingStrategy classNamingStrategy;
+    protected final NamingStrategy propertyNamingStrategy;
+    protected final PropertyDescriptor property;
+
+    protected AbstractMappingContext(MappingProvider<T> mappingProvider,
+            NamingStrategy classNamingStrategy,
+            NamingStrategy propertyNamingStrategy,
+            PropertyDescriptor property) {
+        super(mappingProvider);
+        this.classNamingStrategy = classNamingStrategy;
+        this.propertyNamingStrategy = propertyNamingStrategy;
+        this.property = property;
+    }
+
+    /**
+     * Gets the class naming strategy. This is used to resolve naming
+     * differences in class names between AML and AAS.
+     *
+     * @return the naming strategy
+     */
+    public NamingStrategy getClassNamingStrategy() {
+        return classNamingStrategy;
+    }
+
+    /**
+     * Gets the property naming strategy. This is used to resolve naming
+     * differences in property namings between AML and AAS.
+     *
+     * @return
+     */
+    public NamingStrategy getPropertyNamingStrategy() {
+        return propertyNamingStrategy;
+    }
+
+    /**
+     * Gets the currently processed property if present, otherwise null
+     *
+     * @return the currently processed property if present, otherwise null
+     */
+    public PropertyDescriptor getProperty() {
+        return property;
+    }
+
+}

dataformat-aml/src/main/java/io/adminshell/aas/v3/dataformat/aml/deserialization/AasTypeFactory.java

@@ -50,7 +50,7 @@ public <T> void useImplementation(Class<T> aasInterface, Class<? extends T> impl
      * Creates a new instance for a given aasInterface. If the
      *
      * @param <T> type to create
-     * @param aasInterface class to find instantiate
+     * @param aasInterfaceType class to find instantiate
      * @return an instance of aasInterface
      * @throws NoSuchMethodException
      * @throws InstantiationException
@@ -59,19 +59,34 @@ public <T> void useImplementation(Class<T> aasInterface, Class<? extends T> impl
      * concrete type to instantiate could be found
      * @throws InvocationTargetException
      */
-    public <T> T newInstance(Class<T> aasInterface) throws NoSuchMethodException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
-        if (aasInterface == null) {
+    public <T> T newInstance(Class<T> aasInterfaceType) throws NoSuchMethodException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+        Constructor<?> constructor = getImplementationType(aasInterfaceType).getConstructor();
+        constructor.setAccessible(true);
+        return (T) constructor.newInstance();
+    }
+
+    /**
+     * Gets the concrete implementation type to use for a given type. If there
+     * is no explicit type mapping and the provided type is concrete, the type
+     * itself is returned.
+     *
+     * @param <T> type information
+     * @param aasInterfaceType the type to find a concrete implementation type
+     * for
+     * @throws IllegalArgumentException if there is no type mapping for the
+     * provided type and the type is not concrete
+     * @return a concrete implementation type for the given type
+     */
+    public <T> Class<? extends T> getImplementationType(Class<T> aasInterfaceType) {
+        if (aasInterfaceType == null) {
             throw new IllegalArgumentException("aasInterface must be non-null");
         }
-        Class<?> classToInstantiate = aasInterface;
-        if (typeMapping.containsKey(aasInterface)) {
-            classToInstantiate = typeMapping.get(aasInterface);
+        if (typeMapping.containsKey(aasInterfaceType)) {
+            return (Class<? extends T>) typeMapping.get(aasInterfaceType);
         }
-        if (classToInstantiate.isInterface()) {
-            throw new IllegalArgumentException("could not resolve type for interface " + classToInstantiate.getName());
+        if (aasInterfaceType.isInterface()) {
+            throw new IllegalArgumentException("could not resolve type for interface " + aasInterfaceType.getName());
         }
-        Constructor<?> constructor = classToInstantiate.getConstructor();
-        constructor.setAccessible(true);
-        return (T) constructor.newInstance();
+        return aasInterfaceType;
     }
 }

dataformat-aml/src/main/java/io/adminshell/aas/v3/dataformat/aml/deserialization/Aml2AasMapper.java

@@ -15,13 +15,22 @@
  */
 package io.adminshell.aas.v3.dataformat.aml.deserialization;
 
-import io.adminshell.aas.v3.dataformat.aml.deserialization.mappers.AssetAdministrationShellEnvironmentMapper;
+import io.adminshell.aas.v3.dataformat.aml.deserialization.mappers.*;
 import io.adminshell.aas.v3.dataformat.aml.AmlDeserializationConfig;
 import io.adminshell.aas.v3.dataformat.aml.AmlDocumentInfo;
 import io.adminshell.aas.v3.dataformat.aml.model.caex.CAEXFile;
+import io.adminshell.aas.v3.dataformat.aml.serialization.naming.AbstractClassNamingStrategy;
+import io.adminshell.aas.v3.dataformat.aml.serialization.naming.NumberingClassNamingStrategy;
+import io.adminshell.aas.v3.dataformat.aml.serialization.naming.PropertyNamingStrategy;
 import io.adminshell.aas.v3.dataformat.mapping.MappingException;
 import io.adminshell.aas.v3.dataformat.mapping.MappingProvider;
 import io.adminshell.aas.v3.model.AssetAdministrationShellEnvironment;
+import io.adminshell.aas.v3.model.Identifiable;
+import io.adminshell.aas.v3.model.MultiLanguageProperty;
+import io.adminshell.aas.v3.model.Referable;
+import io.adminshell.aas.v3.model.Qualifiable;
+
+
 import java.util.List;
 
 /**
@@ -49,9 +58,36 @@ public AssetAdministrationShellEnvironment map(CAEXFile aml) throws MappingExcep
         AmlParser parser = new AmlParser(aml);
         MappingProvider mappingProvider = new MappingProvider(Mapper.class, new DefaultMapper(), new DefaultMapper());
         mappingProvider.register(new AssetAdministrationShellEnvironmentMapper());
-        MappingContext context = new MappingContext(mappingProvider, config.getTypeFactory());
+        mappingProvider.register(new EnumMapper());
+        mappingProvider.register(new ReferenceMapper());
+        mappingProvider.register(new AssetAdministrationShellMapper());
+        mappingProvider.register(new LangStringCollectionMapper());
+        mappingProvider.register(new RelationshipElementMapper());
+        mappingProvider.register(new ReferenceElementMapper());
+        mappingProvider.register(new ReferableMapper<Referable>());
+        mappingProvider.register(new IdentifiableMapper<Identifiable>());
+        mappingProvider.register(new ConstraintCollectionMapper());
+        mappingProvider.register(new QualifierMapper());
+        mappingProvider.register(new OperationCollectionMapper());
+        mappingProvider.register(new FileMapper());
+        mappingProvider.register(new RangeMapper());
+        mappingProvider.register(new ViewMapper());
+        mappingProvider.register(new PropertyMapper());
+        mappingProvider.register(new ConceptDescriptionMapper());
+        mappingProvider.register(new EmbeddedDataSpecificationCollectionMapper());
+        mappingProvider.register(new DataSpecificationIEC61360Mapper());
+        mappingProvider.register(new EnumDataTypeIEC61360Mapper());
+        AbstractClassNamingStrategy classNamingStrategy = new NumberingClassNamingStrategy();
+
+        PropertyNamingStrategy propertyNamingStrategy = new PropertyNamingStrategy();
+        propertyNamingStrategy.registerCustomNaming(Referable.class, "descriptions", "description");
+        propertyNamingStrategy.registerCustomNaming(MultiLanguageProperty.class, "values", "value");
+        //propertyNamingStrategy.registerCustomNaming(Qualifier.class, x -> "qualifier:" + x.getType() + "=" + x.getValue(), false);
+        propertyNamingStrategy.registerCustomNaming(Qualifiable.class, "qualifiers", "qualifier","qualifier");
+        MappingContext context = new MappingContext(mappingProvider, classNamingStrategy, propertyNamingStrategy, config.getTypeFactory());
         context.setDocumentInfo(AmlDocumentInfo.fromFile(aml));
-        Object result = context.getMappingProvider().getMapper(AssetAdministrationShellEnvironment.class).map(parser, context);
+        AssetAdministrationShellEnvironment result = context.map(AssetAdministrationShellEnvironment.class, parser);
+        parser.resolveIdsToReferences(result);
         return (AssetAdministrationShellEnvironment) result;
     }
 }