Revize b07f6ea7

re #7885 #8134re #8154 re #8136 added comments and connected switch to allow user to set if he wants to see empty rows or columns in the final table

src/main/java/vldc/aswi/utils/Converter.java

@@ -11 +11 @@
 import java.util.concurrent.TimeUnit;
 
 /**
- * Class for converting classes.
+ * Class used to convert original table to contingency table.
  */
 public class Converter {
 
+    /**
+     * Stores information about whether user set switch to show empty rows and columns to ON.
+     */
     private final boolean isNotRemoveEmpty;
 
+    /**
+     * Map of original table.
+     */
     private final Map<String, TableColumn> tableColumns;
+
+    /**
+     * List of names and user names of selected rows.
+     */
     private final List<NameUserName> rowNames;
+
+    /**
+     * List of names and user names of selected columns.
+     */
     private final List<NameUserName> columnNames;
+
+    /**
+     * List of information about selected value and functions.
+     */
     private final List<ValueFunction> valueFunctions;
 
+    /**
+     * List of columns node of contingency table going from left to right.
+     */
     private List<Node> columnNodes;
+
+    /**
+     * Formatter of the cell content.
+     */
     private final DecimalFormat decimalFormat = new DecimalFormat("0.###");
 
+    /**
+     * Creates and initializes converter.
+     * @param tableColumns Map of original table.
+     * @param rowNames List of names and user names of selected rows.
+     * @param columnNames List of names and user names of selected columns.
+     * @param valueFunctions List of information about selected value and functions.
+     * @param isNotRemoveEmpty Stores information about whether user set switch to show empty rows and columns to ON.
+     */
     public Converter(Map<String, TableColumn> tableColumns, List<NameUserName> rowNames, List<NameUserName> columnNames,
                      List<ValueFunction> valueFunctions, boolean isNotRemoveEmpty) {
         this.tableColumns = tableColumns;
@@ -126 +159 @@
         List<String> prevValues = new ArrayList<>();
         int prevSize = 0;
         for (ValueFunction valueFunction : valueFunctions) {
-            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell(valueFunction.getFunction() + " z " + valueFunction.getName(), 0));
+            headerRows.get(0).addTableRowCell(new ContingencyTableRowCell(valueFunction.getFunction() + " z " + valueFunction.getParameterName(), 0));
             for (Node columnNode : columnNodes) {
                 for (int i = 0; i < columnNode.getValues().size(); i++) {
                     String value = columnNode.getValues().get(i);
@@ -162 +195 @@
                 headerRows.get(i).addTableRowCell(new ContingencyTableRowCell("", 1));
             }
             headerRows.get(0).addTableRowCell(new ContingencyTableRowCell("Celkový " + valueFunction.getFunction() +
-                    " z " + valueFunction.getName(), 1));
+                    " z " + valueFunction.getParameterName(), 1));
         }
 
         return headerRows;
@@ -315 +348 @@
         }
 
         DoubleWrapper[] totals = new DoubleWrapper[valueFunctions.size()];
-        initializeWrapperField(totals);
+        initializeDoubleWrapperField(totals);
 
         DoubleWrapper[] totalsAvgSum = new DoubleWrapper[valueFunctions.size()];
-        initializeWrapperField(totalsAvgSum);
+        initializeDoubleWrapperField(totalsAvgSum);
 
         boolean[] isFilledValueCells = new boolean[valueFunctions.size()];
         //hodnota
@@ -419 +452 @@
         return ids;
     }
 
+    /**
+     * Checks if column is usable by going through all values of columns of a node in the original table.
+     * @param columnNodeValues Values of a column node.
+     * @return True if all values of a node are present in the original table columns.
+     */
     private boolean checkIfColumnIsUsable(List<String> columnNodeValues) {
         for (int i = 0; i < tableColumns.get(columnNames.get(0).getName()).getValues().size(); i++) {
             boolean isUsable = true;
@@ -437 +475 @@
         return false;
     }
 
+    /**
+     * Computes value of the cell in regards to function.
+     * @param valueFunction Function that should be computed for a cell.
+     * @param result Variable to which result is saved.
+     * @param resultAvgSum Variable to which sum is saved of a function is AVG.
+     * @param columnNode Column node of a cell.
+     * @param isFirstMinMax Tells if the counted value is the first value of the MIN or MAX function.
+     * @param usableID ID of the row in the original table.
+     * @param isValueTotal Tells if a value is total value for the given function.
+     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
+     */
     private void computeValues(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
                                BooleanWrapper isFirstMinMax, int usableID, boolean isValueTotal, boolean isSingleValueRow) {
         switch (valueFunction.getFunction()) {
@@ -458 +507 @@
         }
     }
 
+    /**
+     * Generates a cell with filled data.
+     * @param function Name of the function.
+     * @param totalResult Result of COUNT function to be saved.
+     * @param totalResultSum Result of SUM function to be saved.
+     * @param totalMin Result of MIN function to be saved.
+     * @param totalMax Result of MAX function to be saved.
+     * @param totalResultAvgSum Result of sum of AVG function to be saved.
+     * @param totalResultAvg Result of count of AVG function to be saved.
+     * @return Generated and filled cell.
+     */
     private ContingencyTableRowCell generateFilledCell(String function, double totalResult, double totalResultSum,
                                                        double totalMin, double totalMax, double totalResultAvgSum,
                                                        double totalResultAvg) {
@@ -487 +547 @@
         return cell;
     }
 
-    private void initializeWrapperField(DoubleWrapper[] field) {
+    /**
+     * Initializes a filled of the values of a DoubleWrapper type.
+     * @param field Field to be initialized.
+     */
+    private void initializeDoubleWrapperField(DoubleWrapper[] field) {
         for (int i = 0; i < field.length; i++) {
             field[i] = new DoubleWrapper(0);
         }
     }
 
+    /**
+     * Calculates COUNT function.
+     * @param valueFunction Function that should be computed for a cell.
+     * @param result Variable to which result is saved.
+     * @param columnNode Column node of a cell.
+     * @param isValueTotal Tells if a value is total value for the given function.
+     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
+     */
     private void count(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, boolean isValueTotal,
                        boolean isSingleValueRow) {
         result.setValue(result.getValue() + 1);
@@ -504 +576 @@
         }
     }
 
+    /**
+     * Calculates SUM function.
+     * @param valueFunction Function that should be computed for a cell.
+     * @param result Variable to which result is saved.
+     * @param columnNode Column node of a cell.
+     * @param usableID ID of the row in the original table.
+     * @param isValueTotal Tells if a value is total value for the given function.
+     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
+     */
     private void sum(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, int usableID, boolean isValueTotal,
                      boolean isSingleValueRow) {
         if (valueFunction.getType().equals("Číslo")) {
@@ -517 +598 @@
         }
     }
 
+    /**
+     * Calculates MIN function.
+     * @param valueFunction Function that should be computed for a cell.
+     * @param result Variable to which result is saved.
+     * @param columnNode Column node of a cell.
+     * @param isFirstMinMax Tells if the counted value is the first value of the MIN or MAX function.
+     * @param usableID ID of the row in the original table.
+     * @param isValueTotal Tells if a value is total value for the given function.
+     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
+     */
     private void min(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
                      int usableID, boolean isValueTotal, boolean isSingleValueRow) {
         if (valueFunction.getType().equals("Číslo")) {
@@ -546 +637 @@
         }
     }
 
+    /**
+     * Calculates MAX function.
+     * @param valueFunction Function that should be computed for a cell.
+     * @param result Variable to which result is saved.
+     * @param columnNode Column node of a cell.
+     * @param isFirstMinMax Tells if the counted value is the first value of the MIN or MAX function.
+     * @param usableID ID of the row in the original table.
+     * @param isValueTotal Tells if a value is total value for the given function.
+     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
+     */
     private void max(ValueFunction valueFunction, DoubleWrapper result, Node columnNode, BooleanWrapper isFirstMinMax,
                      int usableID, boolean isValueTotal, boolean isSingleValueRow) {
         if (valueFunction.getType().equals("Číslo")) {
@@ -575 +676 @@
         }
     }
 
+    /**
+     * Calculates AVG function.
+     * @param valueFunction Function that should be computed for a cell.
+     * @param result Variable to which count result is saved.
+     * @param resultAvgSum Variable to which sum result is saved.
+     * @param columnNode Column node of a cell.
+     * @param usableID ID of the row in the original table.
+     * @param isValueTotal Tells if a value is total value for the given function.
+     * @param isSingleValueRow Tells whether a row only has single value (only represents one column of the original table).
+     */
     private void average(ValueFunction valueFunction, DoubleWrapper result, DoubleWrapper resultAvgSum, Node columnNode,
                          int usableID, boolean isValueTotal, boolean isSingleValueRow) {
         if (valueFunction.getType().equals("Číslo")) {
@@ -591 +702 @@
         }
     }
 
+    /**
+     * Generates a final row, with total values of columns.
+     * @return Final row filled with data.
+     */
     private ContingencyTableRow createFinalRow() {
         ContingencyTableRow finalRow = new ContingencyTableRow(false, 0);
         finalRow.addTableRowCell(new ContingencyTableRowCell("Celkem", 1));