Copilot commented on code in PR #6427:
URL:
https://github.com/apache/incubator-kie-drools/pull/6427#discussion_r2287894405
##########
kie-dmn/kie-dmn-validation/src/test/java/org/kie/dmn/validation/ValidatorTest.java:
##########
@@ -608,6 +616,42 @@ void validateAllValidSharedModels() throws IOException {
}
}
+ @Test
+ void validateValidModelsWitClashingInheritedImportAndInputNameSimpleData()
{
Review Comment:
Method name has a typo: 'Wit' should be 'With'
```suggestion
void
validateValidModelsWithClashingInheritedImportAndInputNameSimpleData() {
```
##########
kie-dmn/kie-dmn-validation/src/test/java/org/kie/dmn/validation/ValidatorTest.java:
##########
@@ -608,6 +616,42 @@ void validateAllValidSharedModels() throws IOException {
}
}
+ @Test
+ void validateValidModelsWitClashingInheritedImportAndInputNameSimpleData()
{
+ String basePath =
"valid_models/DMNv1_6/imports/same_import_and_input_name_simple_data";
+ String dmnImporting = String.format("%s/ImportingModel.dmn", basePath);
+ String dmnImported = String.format("%s/ImportedModel.dmn", basePath);
+ String[] modelFiles = new String[]{dmnImporting, dmnImported};
+ Resource[] resources =
Arrays.stream(modelFiles).map(ClassPathResource::new).toArray(Resource[]::new);
+ List<DMNMessage> retrieved = validatorBuilder.theseModels(resources);
+ assertThat(retrieved).isNotNull().isEmpty();
+ }
+
+ @Test
+ void
validateValidModelsWitClashingInheritedImportAndInputNameComplexData() {
Review Comment:
Method name has a typo: 'Wit' should be 'With'
```suggestion
void
validateValidModelsWithClashingInheritedImportAndInputNameComplexData() {
```
##########
kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/impl/DMNRuntimeUtils.java:
##########
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.kie.dmn.core.impl;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import org.kie.dmn.api.core.DMNContext;
+import org.kie.dmn.api.core.DMNType;
+import org.kie.dmn.api.core.ast.DMNNode;
+import org.kie.dmn.api.core.ast.InputDataNode;
+import org.kie.dmn.core.util.MsgUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class to support <code>DMNRuntimeImpl</code>
+ */
+public class DMNRuntimeUtils {
+
+ private static final Logger logger =
LoggerFactory.getLogger(DMNRuntimeUtils.class);
+
+ private DMNRuntimeUtils() {
+ // singleton
+ }
+
+
+ public static Object coerceUsingType(Object value, DMNType type, boolean
typeCheck,
+ BiConsumer<Object, DMNType>
nullCallback) {
+ if (typeCheck) {
+ if (type.isAssignableValue(value)) {
+ return coerceSingleItemCollectionToValue(value, type);
+ } else {
+ nullCallback.accept(value, type);
+ return null;
+ }
+ } else {
+ return coerceSingleItemCollectionToValue(value, type);
+ }
+ }
+
+ static void populateResultContextWithTopmostParentsValues(DMNContext
context, DMNModelImpl model) {
+ Optional<Set<DMNModelImpl.ModelImportTuple>> optionalTopmostModels =
getTopmostModel(model);
+ optionalTopmostModels.ifPresent(topmostModels ->
populateInputsFromTopmostModel(context, model, topmostModels));
+ }
+
+ static void populateInputsFromTopmostModel(DMNContext context,
DMNModelImpl model,
+
Set<DMNModelImpl.ModelImportTuple> topmostModels) {
+ for (DMNModelImpl.ModelImportTuple topmostModelTuple : topmostModels) {
+ processTopmostModelTuple(context, topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelTuple(DMNContext context,
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl model) {
+ DMNModelImpl topmostModel = topmostModelTuple.getModel();
+ for (InputDataNode topmostInput : topmostModel.getInputs()) {
+ processTopmostModelInputDataNode(context, topmostInput.getName(),
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNode(DMNContext context, String
topmostInputName,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, DMNModelImpl model) {
+ if (Objects.equals(topmostInputName,
topmostModelTuple.getImportName())) {
+ processTopmostModelInputDataNodeWithClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ } else {
+ processTopmostModelInputDataNodeWithoutClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNodeWithClashingNames(DMNContext
context, String topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl
model) {
+ Object storedValue = context.get(topmostInputName); // This could be
either a raw value, or a map
+ if (storedValue instanceof Map storedMap &&
storedMap.containsKey(topmostInputName)) { // THe check is needed to avoid
looping reference
Review Comment:
Comment has a typo: 'THe' should be 'The'
```suggestion
if (storedValue instanceof Map storedMap &&
storedMap.containsKey(topmostInputName)) { // The check is needed to avoid
looping reference
```
##########
kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/impl/DMNRuntimeUtils.java:
##########
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.kie.dmn.core.impl;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import org.kie.dmn.api.core.DMNContext;
+import org.kie.dmn.api.core.DMNType;
+import org.kie.dmn.api.core.ast.DMNNode;
+import org.kie.dmn.api.core.ast.InputDataNode;
+import org.kie.dmn.core.util.MsgUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class to support <code>DMNRuntimeImpl</code>
+ */
+public class DMNRuntimeUtils {
+
+ private static final Logger logger =
LoggerFactory.getLogger(DMNRuntimeUtils.class);
+
+ private DMNRuntimeUtils() {
+ // singleton
+ }
+
+
+ public static Object coerceUsingType(Object value, DMNType type, boolean
typeCheck,
+ BiConsumer<Object, DMNType>
nullCallback) {
+ if (typeCheck) {
+ if (type.isAssignableValue(value)) {
+ return coerceSingleItemCollectionToValue(value, type);
+ } else {
+ nullCallback.accept(value, type);
+ return null;
+ }
+ } else {
+ return coerceSingleItemCollectionToValue(value, type);
+ }
+ }
+
+ static void populateResultContextWithTopmostParentsValues(DMNContext
context, DMNModelImpl model) {
+ Optional<Set<DMNModelImpl.ModelImportTuple>> optionalTopmostModels =
getTopmostModel(model);
+ optionalTopmostModels.ifPresent(topmostModels ->
populateInputsFromTopmostModel(context, model, topmostModels));
+ }
+
+ static void populateInputsFromTopmostModel(DMNContext context,
DMNModelImpl model,
+
Set<DMNModelImpl.ModelImportTuple> topmostModels) {
+ for (DMNModelImpl.ModelImportTuple topmostModelTuple : topmostModels) {
+ processTopmostModelTuple(context, topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelTuple(DMNContext context,
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl model) {
+ DMNModelImpl topmostModel = topmostModelTuple.getModel();
+ for (InputDataNode topmostInput : topmostModel.getInputs()) {
+ processTopmostModelInputDataNode(context, topmostInput.getName(),
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNode(DMNContext context, String
topmostInputName,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, DMNModelImpl model) {
+ if (Objects.equals(topmostInputName,
topmostModelTuple.getImportName())) {
+ processTopmostModelInputDataNodeWithClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ } else {
+ processTopmostModelInputDataNodeWithoutClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNodeWithClashingNames(DMNContext
context, String topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl
model) {
+ Object storedValue = context.get(topmostInputName); // This could be
either a raw value, or a map
+ if (storedValue instanceof Map storedMap &&
storedMap.containsKey(topmostInputName)) { // THe check is needed to avoid
looping reference
+ return;
+ }
+ // Eventually, we need to create a map with the importing name and
populate it with the input data
+ replaceContextMap(context, topmostModelTuple, topmostInputName,
+ storedValue);
+ }
+
+ static void
processTopmostModelInputDataNodeWithoutClashingNames(DMNContext context, String
topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+
DMNModelImpl model) {
+ Object storedValue = context.get(topmostInputName);
+ if (storedValue != null) {
+ Object parentData = context.get(topmostModelTuple.getImportName());
+ if (parentData instanceof Map mappedData) {
+ addValueInsideMap(mappedData, topmostInputName, storedValue);
+ } else if (parentData == null) {
+ updateContextMap(context, model.getImportChainAliases(),
topmostModelTuple, topmostInputName,
+ storedValue);
+ }
+ }
+ }
+
+ static void replaceContextMap(DMNContext context,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, String inputName,
+ Object storedValue) {
+ Map mappedData = new HashMap<>();
+ mappedData.put(inputName, storedValue);
+ context.set(topmostModelTuple.getImportName(), mappedData);
+ }
+
+ static void updateContextMap(DMNContext context, Map<String,
Collection<List<String>>> importChainAliases,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, String inputName,
+ Object storedValue) {
+ Map mappedData = new HashMap<>();
+ mappedData.put(inputName, storedValue);
+ populateContextWithInheritedData(context, mappedData,
+ topmostModelTuple.getImportName(),
+
topmostModelTuple.getModel().getNamespace(), importChainAliases);
+ }
+
+ /**
+ * This method populate the given <code>DMNContext</code> with a new entry
whose key is the import name and whose value is the provided <code>Map</code>
<b>toStore</b>,
+ * if those are related with the namespace of the topmost parent
+ * @param toPopulate
+ * @param toStore
+ * @param importName
+ * @param topmostNamespace
+ * @param importChainAliases
+ */
+ static void populateContextWithInheritedData(DMNContext toPopulate,
Map<String, Object> toStore,
+ String importName, String
topmostNamespace, Map<String,
+ Collection<List<String>>> importChainAliases) {
+ for (List<String> chainedModels :
importChainAliases.get(topmostNamespace)) {
+ // The order is: first one -> importing model; last one -> parent
model
+ for (String chainedModel : chainedModels) {
+ if (chainedModel.equals(importName)) {
+ continue;
+ }
+ if (toStore.get(chainedModel) != null &&
toStore.get(chainedModel) instanceof Map<?, ?> alreadyMapped) {
+ addValueInsideMap(alreadyMapped, importName, toStore);
+ } else {
+ addNewMapToContext(toPopulate, importName, toStore,
chainedModel);
+ }
+ }
+ }
+ }
+
+ /**
+ * Create a new <code>Map</code> with the given <code>importName</code>
value set to the given <code>Map</code> <b>toStore</b>.
+ * Then, set this newly-created Map in the given <code>DMNContext</code>
as <b>chainedModel</b>
+ * @param toPopulate
+ * @param importName
+ * @param toStore
+ * @param chainedModel
+ */
+ static void addNewMapToContext(DMNContext toPopulate, String importName,
Map<String, Object> toStore, String chainedModel) {
+ Map<String, Object> chainedMap = new HashMap<>();
+ chainedMap.put(importName, toStore);
+ toPopulate.set(chainedModel, chainedMap);
+ }
+
+ /**
+ * Depending on how the context has been instantiated, the provided
<code>Map</code> could be unmodifiable, which
+ * is an expected condition
+ * @param mappedData
+ * @param inputName
+ * @param storedValue
+ */
+ static void addValueInsideMap(Map mappedData, String inputName, Object
storedValue) {
Review Comment:
Raw type usage. Should specify generic types: `Map<String, Object>
mappedData`
```suggestion
static void addValueInsideMap(Map<String, Object> mappedData, String
inputName, Object storedValue) {
```
##########
kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/impl/DMNRuntimeUtils.java:
##########
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.kie.dmn.core.impl;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import org.kie.dmn.api.core.DMNContext;
+import org.kie.dmn.api.core.DMNType;
+import org.kie.dmn.api.core.ast.DMNNode;
+import org.kie.dmn.api.core.ast.InputDataNode;
+import org.kie.dmn.core.util.MsgUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class to support <code>DMNRuntimeImpl</code>
+ */
+public class DMNRuntimeUtils {
+
+ private static final Logger logger =
LoggerFactory.getLogger(DMNRuntimeUtils.class);
+
+ private DMNRuntimeUtils() {
+ // singleton
+ }
+
+
+ public static Object coerceUsingType(Object value, DMNType type, boolean
typeCheck,
+ BiConsumer<Object, DMNType>
nullCallback) {
+ if (typeCheck) {
+ if (type.isAssignableValue(value)) {
+ return coerceSingleItemCollectionToValue(value, type);
+ } else {
+ nullCallback.accept(value, type);
+ return null;
+ }
+ } else {
+ return coerceSingleItemCollectionToValue(value, type);
+ }
+ }
+
+ static void populateResultContextWithTopmostParentsValues(DMNContext
context, DMNModelImpl model) {
+ Optional<Set<DMNModelImpl.ModelImportTuple>> optionalTopmostModels =
getTopmostModel(model);
+ optionalTopmostModels.ifPresent(topmostModels ->
populateInputsFromTopmostModel(context, model, topmostModels));
+ }
+
+ static void populateInputsFromTopmostModel(DMNContext context,
DMNModelImpl model,
+
Set<DMNModelImpl.ModelImportTuple> topmostModels) {
+ for (DMNModelImpl.ModelImportTuple topmostModelTuple : topmostModels) {
+ processTopmostModelTuple(context, topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelTuple(DMNContext context,
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl model) {
+ DMNModelImpl topmostModel = topmostModelTuple.getModel();
+ for (InputDataNode topmostInput : topmostModel.getInputs()) {
+ processTopmostModelInputDataNode(context, topmostInput.getName(),
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNode(DMNContext context, String
topmostInputName,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, DMNModelImpl model) {
+ if (Objects.equals(topmostInputName,
topmostModelTuple.getImportName())) {
+ processTopmostModelInputDataNodeWithClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ } else {
+ processTopmostModelInputDataNodeWithoutClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNodeWithClashingNames(DMNContext
context, String topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl
model) {
+ Object storedValue = context.get(topmostInputName); // This could be
either a raw value, or a map
+ if (storedValue instanceof Map storedMap &&
storedMap.containsKey(topmostInputName)) { // THe check is needed to avoid
looping reference
+ return;
+ }
+ // Eventually, we need to create a map with the importing name and
populate it with the input data
+ replaceContextMap(context, topmostModelTuple, topmostInputName,
+ storedValue);
+ }
+
+ static void
processTopmostModelInputDataNodeWithoutClashingNames(DMNContext context, String
topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+
DMNModelImpl model) {
+ Object storedValue = context.get(topmostInputName);
+ if (storedValue != null) {
+ Object parentData = context.get(topmostModelTuple.getImportName());
+ if (parentData instanceof Map mappedData) {
+ addValueInsideMap(mappedData, topmostInputName, storedValue);
+ } else if (parentData == null) {
+ updateContextMap(context, model.getImportChainAliases(),
topmostModelTuple, topmostInputName,
+ storedValue);
+ }
+ }
+ }
+
+ static void replaceContextMap(DMNContext context,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, String inputName,
+ Object storedValue) {
+ Map mappedData = new HashMap<>();
Review Comment:
Raw type usage. Should specify generic types: `Map<String, Object>
mappedData = new HashMap<>();`
```suggestion
Map<String, Object> mappedData = new HashMap<>();
```
##########
kie-dmn/kie-dmn-core/src/test/java/org/kie/dmn/core/imports/ImportsTest.java:
##########
@@ -44,6 +45,97 @@ public class ImportsTest extends
BaseInterpretedVsCompiledTest {
public static final Logger LOG =
LoggerFactory.getLogger(ImportsTest.class);
+ @ParameterizedTest
+ @MethodSource("params")
+ void importingModelsWithSameImportAndInputNameSimpledData(boolean
useExecModelCompiler) {
Review Comment:
Method name has a typo: 'Simpleddata' should be 'SimpleData'
```suggestion
void importingModelsWithSameImportAndInputNameSimpleData(boolean
useExecModelCompiler) {
```
##########
kie-dmn/kie-dmn-core/src/main/java/org/kie/dmn/core/impl/DMNRuntimeUtils.java:
##########
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 org.kie.dmn.core.impl;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import org.kie.dmn.api.core.DMNContext;
+import org.kie.dmn.api.core.DMNType;
+import org.kie.dmn.api.core.ast.DMNNode;
+import org.kie.dmn.api.core.ast.InputDataNode;
+import org.kie.dmn.core.util.MsgUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Utility class to support <code>DMNRuntimeImpl</code>
+ */
+public class DMNRuntimeUtils {
+
+ private static final Logger logger =
LoggerFactory.getLogger(DMNRuntimeUtils.class);
+
+ private DMNRuntimeUtils() {
+ // singleton
+ }
+
+
+ public static Object coerceUsingType(Object value, DMNType type, boolean
typeCheck,
+ BiConsumer<Object, DMNType>
nullCallback) {
+ if (typeCheck) {
+ if (type.isAssignableValue(value)) {
+ return coerceSingleItemCollectionToValue(value, type);
+ } else {
+ nullCallback.accept(value, type);
+ return null;
+ }
+ } else {
+ return coerceSingleItemCollectionToValue(value, type);
+ }
+ }
+
+ static void populateResultContextWithTopmostParentsValues(DMNContext
context, DMNModelImpl model) {
+ Optional<Set<DMNModelImpl.ModelImportTuple>> optionalTopmostModels =
getTopmostModel(model);
+ optionalTopmostModels.ifPresent(topmostModels ->
populateInputsFromTopmostModel(context, model, topmostModels));
+ }
+
+ static void populateInputsFromTopmostModel(DMNContext context,
DMNModelImpl model,
+
Set<DMNModelImpl.ModelImportTuple> topmostModels) {
+ for (DMNModelImpl.ModelImportTuple topmostModelTuple : topmostModels) {
+ processTopmostModelTuple(context, topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelTuple(DMNContext context,
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl model) {
+ DMNModelImpl topmostModel = topmostModelTuple.getModel();
+ for (InputDataNode topmostInput : topmostModel.getInputs()) {
+ processTopmostModelInputDataNode(context, topmostInput.getName(),
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNode(DMNContext context, String
topmostInputName,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, DMNModelImpl model) {
+ if (Objects.equals(topmostInputName,
topmostModelTuple.getImportName())) {
+ processTopmostModelInputDataNodeWithClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ } else {
+ processTopmostModelInputDataNodeWithoutClashingNames(context,
topmostInputName,
+
topmostModelTuple, model);
+ }
+ }
+
+ static void processTopmostModelInputDataNodeWithClashingNames(DMNContext
context, String topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+ DMNModelImpl
model) {
+ Object storedValue = context.get(topmostInputName); // This could be
either a raw value, or a map
+ if (storedValue instanceof Map storedMap &&
storedMap.containsKey(topmostInputName)) { // THe check is needed to avoid
looping reference
+ return;
+ }
+ // Eventually, we need to create a map with the importing name and
populate it with the input data
+ replaceContextMap(context, topmostModelTuple, topmostInputName,
+ storedValue);
+ }
+
+ static void
processTopmostModelInputDataNodeWithoutClashingNames(DMNContext context, String
topmostInputName,
+
DMNModelImpl.ModelImportTuple topmostModelTuple,
+
DMNModelImpl model) {
+ Object storedValue = context.get(topmostInputName);
+ if (storedValue != null) {
+ Object parentData = context.get(topmostModelTuple.getImportName());
+ if (parentData instanceof Map mappedData) {
+ addValueInsideMap(mappedData, topmostInputName, storedValue);
+ } else if (parentData == null) {
+ updateContextMap(context, model.getImportChainAliases(),
topmostModelTuple, topmostInputName,
+ storedValue);
+ }
+ }
+ }
+
+ static void replaceContextMap(DMNContext context,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, String inputName,
+ Object storedValue) {
+ Map mappedData = new HashMap<>();
+ mappedData.put(inputName, storedValue);
+ context.set(topmostModelTuple.getImportName(), mappedData);
+ }
+
+ static void updateContextMap(DMNContext context, Map<String,
Collection<List<String>>> importChainAliases,
+ DMNModelImpl.ModelImportTuple
topmostModelTuple, String inputName,
+ Object storedValue) {
+ Map mappedData = new HashMap<>();
Review Comment:
Raw type usage. Should specify generic types: `Map<String, Object>
mappedData = new HashMap<>();`
```suggestion
Map<String, Object> mappedData = new HashMap<>();
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
