aswi2020vldc-gitlab/src/main/java/vldc/aswi/utils/Converter.java @ d5ecddcb

package vldc.aswi.utils;

import vldc.aswi.model.table.*;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRow;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRowCell;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Class for converting classes.
 */
public class Converter {

    private final Map<String, TableColumn> tableColumns;
    private final List<NameUserName> rowNames;
    private final List<NameUserName> columnNames;
    private final List<ValueFunction> valueFunctions;

    private List<Node> columnNodes;
    private final DecimalFormat decimalFormat = new DecimalFormat("0.###");

    public Converter(Map<String, TableColumn> tableColumns, List<NameUserName> rowNames, List<NameUserName> columnNames,
                     List<ValueFunction> valueFunctions) {
        this.tableColumns = tableColumns;
        this.rowNames = rowNames;
        this.columnNames = columnNames;
        this.valueFunctions = valueFunctions;
    }

    /**
     * Convert Map of TableColumns into list of ContingencyTableRow.
     * @return List of ContingencyTableRow.
     */
    public List<ContingencyTableRow> convertTableColumnsToContingencyTableRows() {
        long startTime = System.nanoTime();

        long startTime1 = System.nanoTime();
        columnNodes = new ArrayList<>();
        List<List<String>> values = new ArrayList<>();
        for(NameUserName nameUserName : columnNames) {
            TableColumn column = tableColumns.get(nameUserName.getName());
            values.add(getOriginalValuesFromList(column.getValues()));
        }

        Node startNode = new Node();
        generateColumns(0, values, columnNodes, startNode);

        long stopTime1 = System.nanoTime();
        System.out.println("Colums list:" + TimeUnit.MILLISECONDS.convert((stopTime1 - startTime1), TimeUnit.NANOSECONDS));

        List<ContingencyTableRow> contingencyTableRows = new ArrayList<>();

        long startTime2 = System.nanoTime();
        List<ContingencyTableRow> dataRows = createDataRows();
        long stopTime2 = System.nanoTime();
        System.out.println("Rows:" + TimeUnit.MILLISECONDS.convert((stopTime2 - startTime2), TimeUnit.NANOSECONDS));

        long startTime3 = System.nanoTime();
        for (ContingencyTableRow dataRow : dataRows) {
            for (int i = 0; i < columnNodes.size(); i++) {
                if (!columnNodes.get(i).isUsable()) {
                    dataRow.getCells().remove(i + 1);
                }
            }
        }

        columnNodes.removeIf(node -> !node.isUsable());
        long stopTime3 = System.nanoTime();
        System.out.println("Columns remove:" + TimeUnit.MILLISECONDS.convert((stopTime3 - startTime3), TimeUnit.NANOSECONDS));

        long startTime4 = System.nanoTime();
        List<ContingencyTableRow> headerRows = createHeaderOnlyRows();
        long stopTime4 = System.nanoTime();
        System.out.println("Headers:" + TimeUnit.MILLISECONDS.convert((stopTime4 - startTime4), TimeUnit.NANOSECONDS));

        contingencyTableRows.addAll(headerRows);
        contingencyTableRows.addAll(dataRows);

        long stopTime = System.nanoTime();
        System.out.println("Converter:" + TimeUnit.SECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS) + "s");

        return contingencyTableRows;
    }

    /**
     * Generates header rows.
     * @return list of contingency table rows
     */
    private List<ContingencyTableRow> createHeaderOnlyRows() {
        List<ContingencyTableRow> headerRows = new ArrayList<>();

        headerRows.add(new ContingencyTableRow(true, 0));

        for (int i = 0; i < columnNames.size(); i++) {
            headerRows.add(new ContingencyTableRow(true, 0));
        }

        if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC") &&
                columnNames.size() == 0) {
            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Seznam", 1));

            return headerRows;
        }

        for (int i = 0; i < headerRows.size(); i++) {
            ContingencyTableRow headerRow = headerRows.get(i);

            if (i == 0) {
                headerRow.addTableRowCell(new ContingencyTableRowCell("Tabulka", 1));
            }
            else {
                headerRow.addTableRowCell(new ContingencyTableRowCell("", 1));
            }
        }


        List<String> prevValues = new ArrayList<>();
        int prevSize = 0;
        for (ValueFunction valueFunction : valueFunctions) {
            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell(valueFunction.getFunction() + " z " + valueFunction.getName(), 0));
            for (Node columnNode : columnNodes) {
                for (int i = 0; i < columnNode.getValues().size(); i++) {
                    String value = columnNode.getValues().get(i);
                    if (!prevValues.contains(value)) {
                        prevValues.add(value);
                        headerRows.get(i + 1).addTableRowCell(new ContingencyTableRowCell(value, 1));
                        headerRows.get(0).getCells().get(headerRows.get(0).getCells().size() - 1).setColSpan(headerRows.get(0).getCells().get(headerRows.get(0).getCells().size() - 1).getColSpan() + 1);
                    } else if (columnNode.getValues().size() >= prevSize) {
                        headerRows.get(i + 1).getCells().get(headerRows.get(i + 1).getCells().size() - 1).setColSpan(headerRows.get(i + 1).getCells().get(headerRows.get(i + 1).getCells().size() - 1).getColSpan() + 1);
                    }
                }

                if (columnNode.getValues().size() < prevSize) {
                    for (int s = prevSize; s < headerRows.size(); s++) {
                        headerRows.get(s).addTableRowCell(new ContingencyTableRowCell("", 1));
                    }
                    for (int s = 1; s < columnNode.getValues().size(); s++) {
                        headerRows.get(s).getCells().get(headerRows.get(s).getCells().size() - 1).setColSpan(headerRows.get(s).getCells().get(headerRows.get(s).getCells().size() - 1).getColSpan() + 1);
                    }
                    headerRows.get(columnNode.getValues().size()).addTableRowCell(new ContingencyTableRowCell(columnNode.getValues().get(columnNode.getValues().size() - 1) + " Celkem", 1));
                }

                prevSize = columnNode.getValues().size();

                if (!prevValues.isEmpty()) {
                    prevValues.remove(prevValues.size() - 1);
                }
            }
        }

        for (ValueFunction valueFunction : valueFunctions) {
            for (int i = 1; i < headerRows.size(); i++) {
                headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
            }
            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Celkový " + valueFunction.getFunction() +
                    " z " + valueFunction.getName(), 1));
        }

        return headerRows;
    }

    /**
     * Gets original values of a given list.
     * @param list list from which original values should be taken
     * @return list of original values
     */
    private List<String> getOriginalValuesFromList(List<String> list) {
        List<String> origList = new ArrayList<>();

        for (String string : list) {
            if (origList.stream().noneMatch(s -> s.equals(string))) {
                origList.add(string);
            }
        }

        return origList;
    }

    /**
     * Creates data rows.
     * @return list of contingency table rows
     */
    private List<ContingencyTableRow> createDataRows() {
        List<ContingencyTableRow> dataRows = new ArrayList<>();
        List<Node> rowNodes = new ArrayList<>();
        List<List<String>> values = new ArrayList<>();
        for(NameUserName nameUserName : rowNames) {
            TableColumn column = tableColumns.get(nameUserName.getName());
            values.add(getOriginalValuesFromList(column.getValues()));
        }

        long startTime = System.nanoTime();
        Node node = new Node();
        generateRows(dataRows, 0, values, rowNodes, node);
        long stopTime = System.nanoTime();
        System.out.println("Rows List:" + TimeUnit.MILLISECONDS.convert((stopTime - startTime), TimeUnit.NANOSECONDS));

        List<ContingencyTableRow> rowsToBeRemoved = new ArrayList<>();
        for (int i = 0; i < dataRows.size(); i++) {
            if (!fillRowWithData(dataRows.get(i), rowNodes.get(i))) {
                rowsToBeRemoved.add(dataRows.get(i));
            }
        }

        dataRows.removeAll(rowsToBeRemoved);

        if (valueFunctions.get(0).getFunction() != null && (!valueFunctions.get(0).getFunction().equals("NIC") ||
                (valueFunctions.get(0).getFunction().equals("NIC") && columnNames.size() > 0))) {
            dataRows.add(createFinalRow());
        }

        return dataRows;
    }

    /**
     * Recursively generates all possible row combinations, sorted as in contingency table.
     * @param rows list of sorted contingency table rows
     * @param index index in the values list
     * @param values list of lists of values of each query row
     * @param rowNodes list of row nodes
     * @param prevNode parent node of the nodes
     */
    private void generateRows(List<ContingencyTableRow> rows, int index, List<List<String>> values, List<Node> rowNodes,
                              Node prevNode) {
        if (index < values.size()) {
            List<String> list = values.get(index);
            for (String s : list) {
                StringBuilder levelString = new StringBuilder();
                for (int i = 0; i < index; i++) {
                    levelString.append("      ");
                }
                levelString.append(s);
                ContingencyTableRow row = new ContingencyTableRow(false, index);
                row.addTableRowCell(new ContingencyTableRowCell(levelString.toString(), 1));
                rows.add(row);
                Node node = new Node(prevNode);
                node.getValues().add(s);
                rowNodes.add(node);
                int newIndex = index + 1;
                generateRows(rows, newIndex, values, rowNodes, node);
            }
        }
    }

    /**
     * Recursively generates all possible column combinations, sorted as in contingency table.
     * @param index index in the values list
     * @param values list of lists of values of each query row
     * @param columnNodes list of column nodes
     * @param prevNode parent node of the nodes
     */
    private void generateColumns(int index, List<List<String>> values, List<Node> columnNodes, Node prevNode) {
        if (index < values.size()) {
            List<String> list = values.get(index);
            for (String s : list) {
                Node node = new Node(prevNode);
                node.getValues().add(s);
                if (checkIfColumnIsUsable(node.getValues())) {
                    int newIndex = index + 1;
                    generateColumns(newIndex, values, columnNodes, node);
                    columnNodes.add(node);
                }
            }
        }
    }

    /**
     * Fills each data row with data.
     * @param row row to ne filled with data
     * @param node node of the row
     */
    private boolean fillRowWithData(ContingencyTableRow row, Node node) {
        if (valueFunctions.size() == 0) {
            return true;
        }

        boolean isSingleValueRow = false;

        if (node.getValues().size() <= 1) {
            isSingleValueRow = true;
        }

        boolean isRowUsable = false;
        if (columnNodes.size() == 0) {
            columnNodes.add(new Node());
        }

        List<Integer> usableIDs = getUsableIDs(node);

        if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC") &&
                !usableIDs.isEmpty()) {
            return true;
        }

        DoubleWrapper[] totals = new DoubleWrapper[valueFunctions.size()];
        initializeWrapperField(totals);

        DoubleWrapper[] totalsAvgSum = new DoubleWrapper[valueFunctions.size()];
        initializeWrapperField(totalsAvgSum);

        boolean[] isFilledValueCells = new boolean[valueFunctions.size()];
        //hodnota
        for (int v = 0; v < valueFunctions.size(); v++) {
            if (valueFunctions.get(v).getFunction() != null && (valueFunctions.get(v).getFunction().equals("") ||
                    valueFunctions.get(v).getFunction().equals("NIC"))) {
                isRowUsable = true;
                break;
            }
            BooleanWrapper isFirstMinMaxTotal = new BooleanWrapper(true);
            ValueFunction valueFunction = valueFunctions.get(v);
            //sloupec v kont. tabulce
            for (Node columnNode : columnNodes) {
                DoubleWrapper result = new DoubleWrapper(0);
                DoubleWrapper resultAvgSum = new DoubleWrapper(0);
                BooleanWrapper isFirstMinMax = new BooleanWrapper(true);
                boolean isFilledCell = false;
                // radek v orig. tabulce
                for (Integer usableID : usableIDs) {
                    boolean isUsable = true;
                    int j;
                    // zvoleny sloupec ze sloupcu, ziska hodnoty z pouzitelne radky danych sloupcu originalni tabulky a
                    // pokud se vsechny rovnaji hodnotam, ktere jsou ulozeny v hodnotach uzlu na pozici vybraneho
                    // sloupce, je kommbinace pouzitelna k vypoctum
                    for (j = 0; j < columnNode.getValues().size(); j++) {
                        if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(usableID).equals(columnNode.getValues().get(j))) {
                            isUsable = false;
                            break;
                        }
                    }

                    // zvoleny sloupec z hodnot
                    if (tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID) == null) {
                        isUsable = false;
                    }

                    if (isUsable) { // pokud lze hodnotu pouzit, prunik vsech hodnot sedi (ma nejakou hodnotu)
                        columnNode.setUsable(true);
                        isRowUsable = true;
                        isFilledCell = true;
                        computeValues(valueFunction, result, resultAvgSum, columnNode, isFirstMinMax,
                                usableID, false, isSingleValueRow);
                        if (j <= 1) {
                            isFilledValueCells[v] = true;
                            computeValues(valueFunction, totals[v], totalsAvgSum[v], null, isFirstMinMaxTotal,
                                    usableID, true, isSingleValueRow);
                        }
                    }
                }
                if (!isFilledCell) {
                    row.addTableRowCell(new ContingencyTableRowCell("", 0));
                }
                else {
                    row.addTableRowCell(generateFilledCell(valueFunction.getFunction(), result.getValue(), result.getValue(), result.getValue(),
                            result.getValue(), resultAvgSum.getValue(), result.getValue()));
                }
            }
        }
        for (int i = 0; i < valueFunctions.size(); i++) {
            if (valueFunctions.get(i).getFunction() != null && valueFunctions.get(i).getFunction().equals("NIC")) {
                break;
            }
            if (!isFilledValueCells[i]) {
                row.addTableRowCell(new ContingencyTableRowCell("", 0));
            }
            else {
                row.addTableRowCell(generateFilledCell(valueFunctions.get(i).getFunction(), totals[i].getValue(), totals[i].getValue(),
                        totals[i].getValue(), totals[i].getValue(), totalsAvgSum[i].getValue(), totals[i].getValue()));
            }
        }

        return isRowUsable;
    }

    /**
     * Gets a list of IDs of the query rows that fit the contingency table row settings.
     * @param node node of the row
     * @return list of usable IDs
     */
    private List<Integer> getUsableIDs(Node node) {
        List<Integer> ids = new ArrayList<>();

        for (int i = 0; i < tableColumns.get(rowNames.get(0).getName()).getValues().size(); i++) {
            boolean isUsable = true;
            for (int j = 0; j < node.getValues().size(); j++) {
                if (!tableColumns.get(rowNames.get(j).getName()).getValues().get(i).equals(node.getValues().get(j))) {
                    isUsable = false;
                    break;
                }
            }
            if (isUsable) {
                ids.add(i);
            }
        }

        return ids;
    }

    private boolean checkIfColumnIsUsable(List<String> columnNodeValues) {
        for (int i = 0; i < tableColumns.get(columnNames.get(0).getName()).getValues().size(); i++) {
            boolean isUsable = true;
            for (int j = 0; j < columnNodeValues.size(); j++) {
                if (!tableColumns.get(columnNames.get(j).getName()).getValues().get(i).equals(columnNodeValues.get(j))) {
                    isUsable = false;
                    break;
                }
            }

            if (isUsable) {
                return true;
            }
        }

        return false;
    }

    private void computeValues(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
                               BooleanWrapper isFirstMinMax, int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        switch (valueFunction.getFunction()) {
            case "COUNT":
                count(valueFunction, result, columnNode, isValueTotal, isSingleValueRow);
                break;
            case "SUM":
                sum(valueFunction, result, columnNode, usableID, isValueTotal, isSingleValueRow);
                break;
            case "MIN":
                min(valueFunction, result, columnNode, isFirstMinMax, usableID, isValueTotal, isSingleValueRow);
                break;
            case "MAX":
                max(valueFunction, result, columnNode, isFirstMinMax, usableID, isValueTotal, isSingleValueRow);
                break;
            case "AVG":
                average(valueFunction, result, resultAvgSum, columnNode, usableID, isValueTotal, isSingleValueRow);
                break;
        }
    }

    private ContingencyTableRowCell generateFilledCell(String function, double totalResult, double totalResultSum,
                                                       double totalMin, double totalMax, double totalResultAvgSum,
                                                       double totalResultAvg) {
        ContingencyTableRowCell cell = null;
        switch (function) {
            case "COUNT":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalResult), 1);
                break;
            case "SUM":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalResultSum), 1);
                break;
            case "MIN":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalMin), 1);
                break;
            case "MAX":
                cell = new ContingencyTableRowCell(decimalFormat.format(totalMax), 1);
                break;
            case "AVG":
                if (totalResultAvg == 0) {
                    cell = new ContingencyTableRowCell("!!Dělení nulou!!", 0);
                } else {
                    cell = new ContingencyTableRowCell(decimalFormat.format(totalResultAvgSum / totalResultAvg), 0);
                }
                break;
        }

        return cell;
    }

    private void initializeWrapperField(DoubleWrapper[] field) {
        for (int i = 0; i < field.length; i++) {
            field[i] = new DoubleWrapper(0);
        }
    }

    private void count(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, boolean isValueTotal,
                       boolean isSingleValueRow) {
        result.setValue(result.getValue() + 1);
        if (columnNode != null && isSingleValueRow) {
            columnNode.setTotalResult(columnNode.getTotalResult() + 1);
        }
        if (isValueTotal && isSingleValueRow) {
            valueFunction.setTotalResult(valueFunction.getTotalResult() + 1);
        }
    }

    private void sum(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, int usableID, boolean isValueTotal,
                     boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            result.setValue(result.getValue() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            if (columnNode != null && isSingleValueRow) {
                columnNode.setTotalResultSum(columnNode.getTotalResultSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            }
            if (isValueTotal && isSingleValueRow) {
                valueFunction.setTotalResultSum(valueFunction.getTotalResultSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            }
        }
    }

    private void min(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
                     int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            if (isFirstMinMax.isValue()) {
                isFirstMinMax.setValue(false);
                result.setValue(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            }
            else {
                result.setValue(Math.min(result.getValue(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
            }
            if (columnNode != null && isSingleValueRow) {
                if (columnNode.isFirstMin()) {
                    columnNode.setFirstMin(false);
                    columnNode.setTotalMin(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
                } else {
                    columnNode.setTotalMin(Math.min(columnNode.getTotalMin(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
                }
            }
            if (isValueTotal && isSingleValueRow) {
                if (valueFunction.isFirstMin()) {
                    valueFunction.setFirstMin(false);
                    valueFunction.setTotalMin(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
                } else {
                    valueFunction.setTotalMin(Math.min(valueFunction.getTotalMin(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
                }
            }
        }
    }

    private void max(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
                     int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            if (isFirstMinMax.isValue()) {
                isFirstMinMax.setValue(false);
                result.setValue(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            }
            else {
                result.setValue(Math.max(result.getValue(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
            }
            if (columnNode != null && isSingleValueRow) {
                if (columnNode.isFirstMax()) {
                    columnNode.setFirstMax(false);
                    columnNode.setTotalMax(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
                } else {
                    columnNode.setTotalMax(Math.max(columnNode.getTotalMax(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
                }
            }
            if (isValueTotal && isSingleValueRow) {
                if (valueFunction.isFirstMax()) {
                    valueFunction.setFirstMax(false);
                    valueFunction.setTotalMax(Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
                } else {
                    valueFunction.setTotalMax(Math.max(valueFunction.getTotalMax(), Integer.parseInt(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID))));
                }
            }
        }
    }

    private void average(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
                         int usableID, boolean isValueTotal, boolean isSingleValueRow) {
        if (valueFunction.getType().equals("Číslo")) {
            result.setValue(result.getValue() + 1);
            resultAvgSum.setValue(resultAvgSum.getValue() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            if (columnNode != null && isSingleValueRow) {
                columnNode.setTotalResultAvg(columnNode.getTotalResultAvg() + 1);
                columnNode.setTotalResultAvgSum(columnNode.getTotalResultAvgSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            }
            if (isValueTotal && isSingleValueRow) {
                valueFunction.setTotalResultAvg(valueFunction.getTotalResultAvg() + 1);
                valueFunction.setTotalResultAvgSum(valueFunction.getTotalResultAvgSum() + Double.parseDouble(tableColumns.get(valueFunction.getNameOfSelect()).getValues().get(usableID)));
            }
        }
    }

    private ContingencyTableRow createFinalRow() {
        ContingencyTableRow finalRow = new ContingencyTableRow(false, 0);
        finalRow.addTableRowCell(new ContingencyTableRowCell("Celkem", 1));

        if (valueFunctions.get(0).getFunction() != null && valueFunctions.get(0).getFunction().equals("NIC")) {
            return finalRow;
        }

        List<ContingencyTableRowCell> valueCells = new ArrayList<>();
        for (ValueFunction valueFunction : valueFunctions) {
            for (Node columnNode : columnNodes) {
                    finalRow.addTableRowCell(generateFilledCell(valueFunction.getFunction(), columnNode.getTotalResult(), columnNode.getTotalResultSum(),
                            columnNode.getTotalMin(), columnNode.getTotalMax(), columnNode.getTotalResultAvgSum(),
                            columnNode.getTotalResultAvg()));
            }
            valueCells.add(generateFilledCell(valueFunction.getFunction(), valueFunction.getTotalResult(), valueFunction.getTotalResultSum(),
                    valueFunction.getTotalMin(), valueFunction.getTotalMax(), valueFunction.getTotalResultAvgSum(),
                    valueFunction.getTotalResultAvg()));
        }

        finalRow.addTableRowCells(valueCells);

        return finalRow;
    }
}