rm-validation-optimization

.github/dependabot.yml

@@ -6,3 +6,9 @@ updates:
     interval: daily
     time: "11:00"
   open-pull-requests-limit: 10
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "11:00"
+  open-pull-requests-limit: 10

.github/release.yml

@@ -0,0 +1,11 @@
+changelog:
+  categories:
+    - title: Changes
+      labels:
+        - '*'
+      exclude:
+        labels:
+          - dependencies
+    - title: Dependencies
+      labels:
+        - dependencies

.semaphore/semaphore.yml

@@ -3,7 +3,7 @@ name: Java
 agent:
   machine:
     type: e1-standard-2
-    os_image: ubuntu2004
+    os_image: ubuntu2404
 blocks:
   - name: Gradle
     task:
@@ -17,7 +17,7 @@ blocks:
             - sem-version java 17
             - ./gradlew clean build
             - ./gradlew jacocoRootReport
-            - curl https://keybase.io/codecovsecurity/pgp_keys.asc | gpg --no-default-keyring --keyring trustedkeys.gpg --import # One-time step
+            - curl -fsS https://keybase.io/codecovsecops/pgp_keys.asc | gpg --no-default-keyring --keyring trustedkeys.gpg --import # One-time step
             - curl -Os https://uploader.codecov.io/latest/linux/codecov
             - curl -Os https://uploader.codecov.io/latest/linux/codecov.SHA256SUM
             - curl -Os https://uploader.codecov.io/latest/linux/codecov.SHA256SUM.sig

README.md

@@ -18,7 +18,7 @@ You can depend on parts of Archie, or the entire library at once. If you want th
 
 ```gradle
 dependencies {
-    compile 'com.nedap.healthcare.archie:archie-all:3.14.0'
+    compile 'com.nedap.healthcare.archie:archie-all:3.19.0'
 }
 ```
 
@@ -28,11 +28,11 @@ or if you use maven, in your pom.xml
 <dependency>
     <groupId>com.nedap.healthcare.archie</groupId>
     <artifactId>archie-all</artifactId>
-    <version>3.14.0</version>
+    <version>3.19.0</version>
 </dependency>
 ```
 
-If you want to depend on just the AOM and BMM, without any reference model implementation, depend on com.nedap.healthcare.archie:tools:3.14.0 and com.nedap.healthcare.archie:referencemodels:3.14.0 instead
+If you want to depend on just the AOM and BMM, without any reference model implementation, depend on com.nedap.healthcare.archie:tools:3.19.0 and com.nedap.healthcare.archie:referencemodels:3.19.0 instead
 
 
 ## Build
@@ -137,7 +137,7 @@ InMemoryFullArchetypeRepository repository = new InMemoryFullArchetypeRepository
 for(Archetype archetype:allArchetypes) {
     repository.addArchetype(archetype);
 }
-repository.compile(BuiltinReferenceModels.getMetaModels());
+repository.compile(BuiltinReferenceModels.getMetaModelProvider());
 
 for(ValidationResult result:repository.getAllValidationResults()) {
     ... your code here
@@ -149,7 +149,7 @@ The validation result contains the validation result, listing any errors in the
 
 ### Reference model metadata
 
-You may have noticed a call to ```BuiltinReferenceModels.getMetaModels()```. This retrieves the metadata for the reference models, which are needed to validate and flatten archetypes. Archie contains two types of metamodels: BMM, and reflection based metadata.
+You may have noticed a call to ```BuiltinReferenceModels.getMetaModelProvider()```. This retrieves the metadata for the reference models, which are needed to validate and flatten archetypes. Archie contains two types of metamodels: BMM, and reflection based metadata.
 The BMM models are a file containing metadata in a form defined by the openEHR specifications.
 The reflection based metadata contains ModelInfoLookup classes. They are derived from an implementation of a reference model. Note that the ModelInfoLookup classes are only added if you depended on them. If you depended on archie-all, you're all set.
 
@@ -162,7 +162,7 @@ Note that ADL 2 operational templates is fundamentally different from the ADL 1.
 To create an Operational Template:
 
 ```java
-Flattener flattener = new Flattener(repository, BuiltinReferenceModels.getMetaModels()).createOperationalTemplate(true);
+Flattener flattener = new Flattener(repository, BuiltinReferenceModels.getMetaModelProvider()).createOperationalTemplate(true);
 OperationalTemplate template = (OperationalTemplate) flattener.flatten(sourceArchetype);
 ```
 
@@ -221,7 +221,7 @@ The inverse operation of flattening archetypes is diffing. This is useful if you
 ```java
 Archetype flatChild, flatParent; //for how to parse and flatten, see elsewhere in the readme
 
-Differentiator differentiator = new Differentiator(BuiltinReferenceModels.getMetaModels());
+Differentiator differentiator = new Differentiator(BuiltinReferenceModels.getMetaModelProvider());
 Archetype diffed = differentiator.differentiate(flatChild, flatParent);
 ```
 
@@ -246,7 +246,7 @@ It also does not yet diff the rules section, this must be manually performed.
 
 ### Serializing to ADL
 
-Archetype models can be serialized to ADL thanks the the serializer written by @markopi64 from Marand Labs. To use:
+Archetype models can be serialized to ADL thanks to the serializer written by @markopi64 from Marand Labs. To use:
 
 ```java
 String serialized = ADLArchetypeSerializer.serialize(archetype);
@@ -391,7 +391,7 @@ If you want to do this yourself, The RMObjectCreator creates empty reference mod
 
 Setting primitive object values works in a similar way, with ```creator.set(...)```, or by setting them explicitly on the reference model object directly.
 
-Notice the call to ```ArchieRMInfoLookup.getInstance()```, which obtains the metadata about the reference model implementation. It can also be obtained from the result of ```BuiltinReferenceModels.getMetaModels()```, or you can define your own to make Archie work with your own reference model implementation.
+Notice the call to ```ArchieRMInfoLookup.getInstance()```, which obtains the metadata about the reference model implementation. It can also be obtained from the result of ```BuiltinReferenceModels.getMetaModelProvider()```, or you can define your own to make Archie work with your own reference model implementation.
 
 ### Parsing JSON
 
@@ -456,10 +456,10 @@ Starting from version 0.7, Archie can import ADL 1.4 files, and convert them to
 
 ```java
 ADL14ConversionConfiguration conversionConfiguration = new ADL14ConversionConfiguration();
-ADL14Converter converter = new ADL14Converter(BuiltinReferenceModels.getMetaModels(), conversionConfiguration);
+ADL14Converter converter = new ADL14Converter(BuiltinReferenceModels.getMetaModelProvider(), conversionConfiguration);
 
 List<Archetype> archetypes = new ArrayList<>();
-ADL14Parser parser = new ADL14Parser(BuiltinReferenceModels.getMetaModels());
+ADL14Parser parser = new ADL14Parser(BuiltinReferenceModels.getMetaModelProvider());
 
 for(String file:fileNames) {
    try(InputStream stream = new FileInputStream(file)) {

adlchecker/build.gradle

@@ -15,4 +15,4 @@ run {
     args = ['archetypes', '--lint']//, '--outputFlat']
 }
 
-mainClassName='com.nedap.archie.adlchecker.AdlChecker'
+mainClassName = 'com.nedap.archie.adlchecker.AdlChecker'

aom/build.gradle

@@ -1,10 +1,12 @@
 description = "An OpenEHR archetype object model implementation, plus parser"
 
 dependencies {
-  api project(':grammars')
-  api project(':base')
-  api project(':odin')
-  api project(':utils')
-  api project(':bmm')
-  api project(':openehr-terminology')
-}
+    api project(':grammars')
+    api project(':base')
+    api project(':odin')
+    api project(':utils')
+    api project(':bmm')
+    api project(':openehr-terminology')
+
+    testImplementation project(':archie-utils')
+}

aom/src/main/java/com/nedap/archie/adl14/ADL14DefaultMultiplicitiesSetter.java

@@ -4,6 +4,8 @@
 import com.nedap.archie.aom.CAttribute;
 import com.nedap.archie.aom.CObject;
 import com.nedap.archie.base.MultiplicityInterval;
+import com.nedap.archie.rminfo.MetaModel;
+import com.nedap.archie.rminfo.MetaModelProvider;
 import com.nedap.archie.rminfo.MetaModels;
 
 /**
@@ -17,24 +19,32 @@
  */
 public class ADL14DefaultMultiplicitiesSetter {
 
-    private final MetaModels metaModels;
+    private final MetaModelProvider metaModelProvider;
 
+    /**
+     * @deprecated Use {@link #ADL14DefaultMultiplicitiesSetter(MetaModelProvider)} instead.
+     */
+    @Deprecated
     public ADL14DefaultMultiplicitiesSetter(MetaModels metaModels) {
-        this.metaModels = metaModels;
+        this((MetaModelProvider) metaModels);
+    }
+
+    public ADL14DefaultMultiplicitiesSetter(MetaModelProvider metaModelProvider) {
+        this.metaModelProvider = metaModelProvider;
     }
 
     public void setDefaults(Archetype archetype) {
-        metaModels.selectModel(archetype);
-        correctItemsMultiplicities(archetype.getDefinition());
+        MetaModel metaModel = metaModelProvider.selectAndGetMetaModel(archetype);
+        correctItemsMultiplicities(metaModel, archetype.getDefinition());
     }
 
-    private void correctItemsMultiplicities(CObject cObject) {
+    private void correctItemsMultiplicities(MetaModel metaModel, CObject cObject) {
         for (CAttribute attribute : cObject.getAttributes()) {
             for (CObject child : attribute.getChildren()) {
-                if (child.getOccurrences() == null && metaModels.isMultiple(cObject.getRmTypeName(), attribute.getRmAttributeName())) {
+                if (child.getOccurrences() == null && metaModel.isMultiple(cObject.getRmTypeName(), attribute.getRmAttributeName())) {
                     child.setOccurrences(new MultiplicityInterval(1, 1));
                 }
-                correctItemsMultiplicities(child);
+                correctItemsMultiplicities(metaModel, child);
             }
         }
 

aom/src/main/java/com/nedap/archie/adl14/ADL14NodeIDConverter.java

@@ -13,6 +13,8 @@
 import com.nedap.archie.base.Cardinality;
 import com.nedap.archie.paths.PathSegment;
 import com.nedap.archie.query.APathQuery;
+import com.nedap.archie.rminfo.MetaModel;
+import com.nedap.archie.rminfo.MetaModelProvider;
 import com.nedap.archie.rminfo.MetaModels;
 import com.nedap.archie.rules.*;
 
@@ -33,7 +35,8 @@ public class ADL14NodeIDConverter {
     private final ADL14TermConstraintConverter termConstraintConverter;
     private final PreviousConversionApplier previousConversionApplier;
     private final ADL2ConversionResult conversionResult;
-    private final MetaModels metaModels;
+    private final MetaModelProvider metaModelProvider;
+    private final MetaModel metaModel;
 
     private IdCodeGenerator idCodeGenerator;
 
@@ -45,8 +48,17 @@ public class ADL14NodeIDConverter {
     private final Map<String, ValueSet> createdValueSets = new LinkedHashMap<>();
     private final Map<String, String> newCodeToOldCodeMap = new LinkedHashMap<>();
 
+    /**
+     * @deprecated Use {@link #ADL14NodeIDConverter(MetaModelProvider, Archetype, Archetype, ADL14ConversionConfiguration, ADL2ConversionLog, ADL2ConversionResult)} instead.
+     */
+    @Deprecated
     public ADL14NodeIDConverter(MetaModels metaModels, Archetype archetype, Archetype flatParentArchetype, ADL14ConversionConfiguration configuration, ADL2ConversionLog oldLog, ADL2ConversionResult conversionResult) {
-        this.metaModels = metaModels;
+        this((MetaModelProvider) metaModels, archetype, flatParentArchetype, configuration, oldLog, conversionResult);
+    }
+
+    public ADL14NodeIDConverter(MetaModelProvider metaModelProvider, Archetype archetype, Archetype flatParentArchetype, ADL14ConversionConfiguration configuration, ADL2ConversionLog oldLog, ADL2ConversionResult conversionResult) {
+        this.metaModelProvider = metaModelProvider;
+        this.metaModel = metaModelProvider.getMetaModel(archetype);
         this.conversionConfiguration = configuration;
         this.archetype = archetype;
         this.flatParentArchetype = flatParentArchetype;
@@ -61,7 +73,7 @@ public ADL14ConversionConfiguration getConversionConfiguration() {
     }
 
     public ADL2ConversionLog convert() {
-        metaModels.selectModel(archetype);
+        metaModelProvider.selectAndGetMetaModel(archetype); // For backwards compatibility
 
         correctItemsCardinality(archetype.getDefinition());
         List<String> unnecessaryCodes = findUnnecessaryCodes(archetype.getDefinition(),
@@ -123,7 +135,7 @@ private List<String> findUnnecessaryCodes(CObject cObject, Map<String, Archetype
         ArchetypeTerm term = originalLanguageTermDefinitions.get(code);
         if (term != null && term.getText() != null && term.getText().length() < 19
                 && term.getDescription() != null && term.getDescription().contains("@ internal @")) {
-            if (!cObject.isRootNode() && !parentIsMultiple(cObject, flatParentArchetype, metaModels)) {
+            if (!cObject.isRootNode() && !parentIsMultiple(cObject, flatParentArchetype, metaModel)) {
                 result.add(code);
             }
         }
@@ -140,29 +152,32 @@ private List<String> findUnnecessaryCodes(CObject cObject, Map<String, Archetype
      * Replace old id's in term definition with the new codes
      */
     public static void convertTermDefinitions(Archetype archetype, Map<String, ConvertedCodeResult> convertedCodes, List<String> unnecessaryCodes) {
-        //process the codes in alphabetical order, high to low, to prevent overwriting codes
-        //even better would probably be to create an empty terminology and separate all new+converted codes and old codes
-        //instead of doing this in place. Worth a refactor perhaps?
-        ArrayList<ConvertedCodeResult> sortedCodes = new ArrayList<>(convertedCodes.values());
-        Comparator<ConvertedCodeResult> comparator = Comparator.comparing(ConvertedCodeResult::getOriginalCode);
-        sortedCodes.sort(comparator.reversed());
-
-        for (ConvertedCodeResult convertedCode : sortedCodes) {
-            for (String language : archetype.getTerminology().getTermDefinitions().keySet()) {
-                Map<String, ArchetypeTerm> terms = archetype.getTerminology().getTermDefinitions().get(language);
-                ArchetypeTerm term = terms.remove(convertedCode.getOriginalCode());
-                if (term != null && !unnecessaryCodes.contains(convertedCode.getOriginalCode())) {
-                    for (String newCode : convertedCode.getConvertedCodes()) {
-                        ArchetypeTerm newTerm = new ArchetypeTerm();
-                        newTerm.setCode(newCode);
-                        newTerm.setText(term.getText());
-                        newTerm.setDescription(term.getDescription());
-                        newTerm.putAll(term.getOtherItems());
-                        terms.put(newCode, term);
+        archetype.getTerminology().getTermDefinitions().replaceAll((language, terms) -> {
+            Map<String, ArchetypeTerm> newTerms = new LinkedHashMap<>();
+
+            for (Map.Entry<String, ArchetypeTerm> entry : terms.entrySet()) {
+                String oldCode = entry.getKey();
+                if (!unnecessaryCodes.contains(oldCode)) {
+                    ArchetypeTerm term = entry.getValue();
+                    ConvertedCodeResult convertedCode = convertedCodes.get(oldCode);
+                    if (convertedCode != null) {
+                        for (String newCode : convertedCode.getConvertedCodes()) {
+                            ArchetypeTerm newTerm = new ArchetypeTerm();
+                            newTerm.setCode(newCode);
+                            newTerm.setText(term.getText());
+                            newTerm.setDescription(term.getDescription());
+                            newTerm.putAll(term.getOtherItems());
+                            newTerms.put(newCode, newTerm);
+                        }
+                    } else {
+                        // Code is not converted, copy it.
+                        newTerms.put(oldCode, term);
                     }
                 }
             }
-        }
+
+            return newTerms;
+        });
 
         //the terminology can still contain old unused codes now. The archetype validation will warn about that later
     }
@@ -245,7 +260,7 @@ private void generateMissingNodeIds(CObject cObject) {
                         synthesizeNodeId(cObject, path);
                         conversionResult.getLog().addWarningWithLocation(ADL14ConversionMessageCode.WARNING_SPECIALIZED_FIRST_MATCHING_CHILD, cObject.path());
                     } else if (cAttributeInParent.getChildren().size() == 1 || cObject.getParent().getChildren().size() == 1) {
-                        if (this.metaModels.rmTypesConformant(cObject.getRmTypeName(), cAttributeInParent.getChildren().get(0).getRmTypeName())) {
+                        if (this.metaModel.rmTypesConformant(cObject.getRmTypeName(), cAttributeInParent.getChildren().get(0).getRmTypeName())) {
                             //this replaces a parent node, so a specialisation. add id code and possibly a term
                             createSpecialisedNodeId(cObject, path, Arrays.asList(cAttributeInParent.getChildren().get(0)));
                         } else {

aom/src/main/java/com/nedap/archie/adl14/ADL14Parser.java

@@ -11,6 +11,8 @@
 import com.nedap.archie.antlr.errors.ArchieErrorListener;
 import com.nedap.archie.aom.Archetype;
 import com.nedap.archie.aom.utils.ArchetypeParsePostProcessor;
+import com.nedap.archie.rminfo.MetaModel;
+import com.nedap.archie.rminfo.MetaModelProvider;
 import com.nedap.archie.rminfo.MetaModels;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
@@ -29,7 +31,7 @@
  */
 public class ADL14Parser {
 
-    private final MetaModels metaModels;
+    private final MetaModelProvider metaModelProvider;
     private ANTLRParserErrors errors;
 
     private Lexer lexer;
@@ -44,8 +46,16 @@ public class ADL14Parser {
      */
     private boolean logEnabled = true;
 
+    /**
+     * @deprecated Use {@link #ADL14Parser(MetaModelProvider)} instead.
+     */
+    @Deprecated
     public ADL14Parser(MetaModels models) {
-        this.metaModels = models;
+        this((MetaModelProvider) models);
+    }
+
+    public ADL14Parser(MetaModelProvider metaModelProvider) {
+        this.metaModelProvider = metaModelProvider;
     }
 
     public Archetype parse(String adl, ADL14ConversionConfiguration conversionConfiguration) throws ADLParseException {
@@ -75,13 +85,13 @@ public Archetype parse(CharStream stream, ADL14ConversionConfiguration conversio
             walker.walk(listener, tree);
             result = listener.getArchetype();
             ArchetypeParsePostProcessor.fixArchetype(result);
-            if (metaModels != null) {
-                metaModels.selectModel(result);
-                if (metaModels.getSelectedBmmModel() != null) {
-                    ModelConstraintImposer imposer = new BMMConstraintImposer(metaModels.getSelectedBmmModel());
+            if (metaModelProvider != null) {
+                MetaModel metaModel = metaModelProvider.selectAndGetMetaModel(result);
+                if (metaModel.getBmmModel() != null) {
+                    ModelConstraintImposer imposer = new BMMConstraintImposer(metaModel.getBmmModel());
                     imposer.setSingleOrMultiple(result.getDefinition());
-                } else if (metaModels.getSelectedModelInfoLookup() != null) {
-                    ModelConstraintImposer imposer = new ReflectionConstraintImposer(metaModels.getSelectedModelInfoLookup());
+                } else if (metaModel.getModelInfoLookup() != null) {
+                    ModelConstraintImposer imposer = new ReflectionConstraintImposer(metaModel.getModelInfoLookup());
                     imposer.setSingleOrMultiple(result.getDefinition());
                 }
             }