io.wizzie.normalizer.funcs.impl.ArithmeticMapper Maven / Gradle / Ivy

Go to download
package io.wizzie.normalizer.funcs.impl;

import io.wizzie.metrics.MetricsManager;
import io.wizzie.normalizer.funcs.MapperFunction;
import org.apache.kafka.streams.KeyValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import parsii.eval.Expression;
import parsii.eval.Parser;
import parsii.eval.Scope;
import parsii.eval.Variable;
import parsii.tokenizer.ParseException;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.cookingfox.guava_preconditions.Preconditions.checkNotNull;

public class ArithmeticMapper extends MapperFunction {

    List> equations;
    Map variableMap = new HashMap<>();
    Map equationMap = new HashMap<>();
    Scope scope = Scope.create();
    private static final Logger log = LoggerFactory.getLogger(ArithmeticMapper.class);

    @Override
    public void prepare(Map properties, MetricsManager metricsManager) {

        equations = (List>) checkNotNull(properties.get("equations"), "equations cannot be null");
        for (Map equation : equations) {
            checkNotNull(equation.get("as"), "as cannot be null");
            checkNotNull(equation.get("equation"), "equation cannot be null");
            checkNotNull(equation.get("dimensions"), "dimensions cannot be null");
        }

        for (Map equation : equations) {
            List dimensions = (List) equation.get("dimensions");
            for (String dimension : dimensions) {
                if (!variableMap.containsKey(dimension)) {
                    Variable var = scope.getVariable(dimension);
                    variableMap.put(dimension, var);
                }
            }
            try {
                Expression expr = Parser.parse((String) equation.get("equation"), scope);
                equationMap.put((String) equation.get("equation"), expr);
            } catch (ParseException e) {
                log.error(e.getMessage(), e);
            }
        }
    }

    @Override
    public KeyValue> process(String key, Map value) {

        if (value != null) {

            for (Map equation : equations) {
                boolean everyVarExist = true;
                for (String dimension : ((List) equation.get("dimensions"))) {
                    Object value2Set = value.get(dimension);
                    if (value2Set != null) {
                        try {
                            Number number = (Number) value2Set;
                            variableMap.get(dimension).setValue(number.doubleValue());
                        } catch (Exception e) {
                            everyVarExist = false;
                            log.debug(e.getMessage(), e);
                        }
                    } else {
                        everyVarExist = false;
                        log.debug("Dimension: " + dimension + " doesn't exist to evaluate the arithmetic expression.");
                        break;
                    }
                }

                if (everyVarExist) {
                    value.put((String) equation.get("as"), equationMap.get(equation.get("equation").toString()).evaluate());
                }
            }

            return new KeyValue<>(key, value);
        } else {
            return new KeyValue<>(key, null);
        }
    }


    public List> getEquations() {
        return equations;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("{");
        builder.append("equations: ");
        builder.append(equations);
        builder.append("}");

        return builder.toString();
    }

    @Override
    public void stop() {

    }
}