• Home
• com.goldmansachs.jdmn
• jdmn-core
• 8.7.3
• source code
• AbstractDMNInterpreter.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.gs.dmn.runtime.interpreter.AbstractDMNInterpreter Maven / Gradle / Ivy

/*
 * Copyright 2016 Goldman Sachs.
 *
 * 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 com.gs.dmn.runtime.interpreter;

import com.gs.dmn.DMNModelRepository;
import com.gs.dmn.DRGElementReference;
import com.gs.dmn.ImportPath;
import com.gs.dmn.QualifiedName;
import com.gs.dmn.ast.*;
import com.gs.dmn.ast.visitor.NopVisitor;
import com.gs.dmn.context.DMNContext;
import com.gs.dmn.context.environment.EnvironmentFactory;
import com.gs.dmn.el.analysis.semantics.type.NullType;
import com.gs.dmn.el.analysis.semantics.type.Type;
import com.gs.dmn.el.analysis.syntax.ast.expression.Expression;
import com.gs.dmn.el.interpreter.ELInterpreter;
import com.gs.dmn.error.ErrorHandler;
import com.gs.dmn.error.LogErrorHandler;
import com.gs.dmn.feel.analysis.semantics.type.*;
import com.gs.dmn.feel.analysis.syntax.ast.expression.function.FormalParameter;
import com.gs.dmn.feel.analysis.syntax.ast.expression.textual.FilterExpression;
import com.gs.dmn.feel.analysis.syntax.ast.test.UnaryTests;
import com.gs.dmn.feel.lib.FEELLib;
import com.gs.dmn.log.BuildLogger;
import com.gs.dmn.log.Slf4jBuildLogger;
import com.gs.dmn.runtime.*;
import com.gs.dmn.runtime.annotation.HitPolicy;
import com.gs.dmn.runtime.function.DMNFunction;
import com.gs.dmn.runtime.function.DMNInvocable;
import com.gs.dmn.runtime.function.Function;
import com.gs.dmn.runtime.listener.EventListener;
import com.gs.dmn.runtime.listener.*;
import com.gs.dmn.transformation.basic.BasicDMNToNativeTransformer;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.xml.namespace.QName;
import java.util.*;
import java.util.stream.Collectors;

import static com.gs.dmn.el.analysis.semantics.type.AnyType.ANY;

public abstract class AbstractDMNInterpreter implements DMNInterpreter {
    protected static final Logger LOGGER = LoggerFactory.getLogger(AbstractDMNInterpreter.class);

    protected static EventListener EVENT_LISTENER = new LoggingEventListener(LOGGER);
    public static void setEventListener(EventListener eventListener) {
        EVENT_LISTENER = eventListener;
    }

    private final DMNModelRepository repository;
    private final EnvironmentFactory environmentFactory;

    protected final BuildLogger logger;
    protected final ErrorHandler errorHandler;

    protected final BasicDMNToNativeTransformer dmnTransformer;
    protected final FEELLib feelLib;
    protected ELInterpreter elInterpreter;
    protected TypeChecker typeChecker;

    protected InterpreterVisitor visitor;

    protected AbstractDMNInterpreter(BasicDMNToNativeTransformer dmnTransformer, FEELLib feelLib) {
        this.logger = new Slf4jBuildLogger(LOGGER);
        this.errorHandler = new LogErrorHandler(LOGGER);
        this.dmnTransformer = dmnTransformer;
        this.repository = dmnTransformer.getDMNModelRepository();
        this.environmentFactory = dmnTransformer.getEnvironmentFactory();
        this.feelLib = feelLib;
        this.visitor = new InterpreterVisitor(logger, this.errorHandler);
    }

    @Override
    public BasicDMNToNativeTransformer getBasicDMNTransformer() {
        return this.dmnTransformer;
    }

    @Override
    public ELInterpreter getElInterpreter() {
        return this.elInterpreter;
    }

    @Override
    public FEELLib getFeelLib() {
        return this.feelLib;
    }

    @Override
    public TypeChecker getTypeChecker() {
        return this.typeChecker;
    }

    //
    // Evaluate DRG elements
    //
    @Override
    public Result evaluateDecision(String namespace, String decisionName, EvaluationContext context) {
        try {
            TDRGElement element = this.repository.findDRGElementByName(namespace, decisionName);
            if (element instanceof TDecision) {
                // Infer types for InputData
                Map informationRequirements = ((DecisionEvaluationContext) context).getInformationRequirements();
                Map> inferredTypes = inferInputDataType(element, informationRequirements);
                // Make context
                DRGElementReference reference = this.repository.makeDRGElementReference((TDecision) element);
                DMNContext decisionContext = makeDecisionGlobalContext(element, informationRequirements);
                // Evaluate decision
                Result result = this.visitor.visitDecisionReference(reference, decisionContext);
                // Restore original types
                restoreOriginalTypes(inferredTypes);
                return result;
            } else {
                throw new DMNRuntimeException(String.format("Cannot find decision namespace='%s' name='%s'", namespace, decisionName));
            }
        } catch (Exception e) {
            return handleEvaluationError(namespace, "decision", decisionName, e);
        }
    }

    private Map> inferInputDataType(TDRGElement element, Map informationRequirements) {
        Map> result = new LinkedHashMap<>();
        if (!this.dmnTransformer.isStrongTyping()) {
            TDefinitions model = this.repository.getModel(element);
            for (Map.Entry entry: informationRequirements.entrySet()) {
                String inputDataName = entry.getKey();
                Object value = entry.getValue();
                TDRGElement drgElementByName = findInputData(model, inputDataName);
                if (drgElementByName instanceof TInputData) {
                    TInputData inputData = (TInputData) drgElementByName;
                    TInformationItem variable = inputData.getVariable();
                    String originalTypeRef = QualifiedName.toName(variable.getTypeRef());
                    if (Type.isNullOrAny(originalTypeRef)) {
                        String inferredType = null;
                        if (feelLib.isNumber(value)) {
                            inferredType = NumberType.NUMBER.getName();
                        } else if (feelLib.isBoolean(value)) {
                            inferredType = BooleanType.BOOLEAN.getName();
                        } else if (feelLib.isString(value)) {
                            inferredType = StringType.STRING.getName();
                        } else if (feelLib.isDate(value)) {
                            inferredType = DateType.DATE.getName();
                        } else if (feelLib.isTime(value)) {
                            inferredType = TimeType.TIME.getName();
                        } else if (feelLib.isDateTime(value)) {
                            inferredType = DateTimeType.DATE_AND_TIME.getName();
                        } else if (feelLib.isDaysAndTimeDuration(value)) {
                            inferredType = DaysAndTimeDurationType.DAYS_AND_TIME_DURATION.getName();
                        } else if (feelLib.isYearsAndMonthsDuration(value)) {
                            inferredType = YearsAndMonthsDurationType.YEARS_AND_MONTHS_DURATION.getName();
                        }
                        if (inferredType != null) {
                            variable.setTypeRef(new QName(inferredType));
                            result.put(inputData, new Pair<>(originalTypeRef, inferredType));
                        }
                    }
                }
            }
        }
        return result;
    }

    private void restoreOriginalTypes(Map> inferredTypes) {
        if (!this.dmnTransformer.isStrongTyping()) {
            for(Map.Entry> entry: inferredTypes.entrySet()) {
                TInputData inputData = entry.getKey();
                String originalTypeRef = entry.getValue().getLeft();
                inputData.getVariable().setTypeRef(originalTypeRef == null ? null : new QName(originalTypeRef));
            }
        }
    }

    private TDRGElement findInputData(TDefinitions model, String inputDataName) {
        try {
            return this.repository.findDRGElementByName(model, inputDataName);
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public Result evaluateInvocable(String namespace, String invocableName, EvaluationContext context) {
        List