public Object getValue(int col, int row) { if (row < firstRowHeight) { return null; // the row 0 contains column headers } if (col < firstColWidth) { return null; } if (res.getWidth() <= col - firstColWidth || res.getHeight() <= row - firstRowHeight) { return null; } return res.getValue(row - firstRowHeight, col - firstColWidth); }
@Override public Object newInstance(IRuntimeEnv env) { Object[][] result = new Object[rowNames.length][columnNames.length]; return new SpreadsheetResult(result, rowNames.clone(), columnNames.clone(), fieldsCoordinates); }
private boolean anyNestedValueInRow(SpreadsheetResult spreadsheetResult, int row) { List<ColumnToExtract> compoundColumns = conf.getCompoundColumnsToExtract(currentNestingLevel); for (ColumnToExtract column : compoundColumns) { int columnIndex = SpreadsheetResultHelper.getColumnIndexByName(column.getColumnName(), spreadsheetResult.getColumnNames()); Object valueInColumn = spreadsheetResult.getValue(row, columnIndex); if (containsNested(valueInColumn)) { return true; } } return false; }
private String getStringValue(int col, int row) { if (col == 0 && row == 0) return "-X-"; if (col == 0) return getRowName(row - 1); if (row == 0) return getColumnName(col - 1); Object value = getValue(row - 1, col - 1); return value == null ? "" : String.valueOf(value); } }
public Object getFieldValue(String name) { if (fieldsCoordinates == null) { // Required if default constructor is // used with setter methods. initFieldsCoordinates(); } Point fieldCoordinates = fieldsCoordinates.get(name); if (fieldCoordinates != null) { return getValue(fieldCoordinates.getRow(), fieldCoordinates.getColumn()); } return null; }
if (spreadsheetResult == null) { // Copy Spreadsheet SpreadsheetResult spr = convertationMetadata.getSpreadsheetResult(); spreadsheetResult = new SpreadsheetResult(); spreadsheetResult.setColumnNames(spr.getColumnNames()); spreadsheetResult.setRowNames(spr.getRowNames()); result = new Object[spr.getHeight()][spr.getWidth()]; Object value = getValue(calculationStep, property); Object originalValue = convertationMetadata.getSpreadsheetResult() .getValue(spreadsheetResultPoint.getRowIndex(), spreadsheetResultPoint.getColumnIndex()); if (originalValue != null) { value = convert(convertor, value, originalValue.getClass()); spreadsheetResult.setResults(result); return spreadsheetResult;
public FormattedCell filterFormat(FormattedCell cell) { ILogicalTable table = res.getLogicalTable(); if (row >= 0 && col >= 0 && res.getWidth() > col && res.getHeight() > row) { Object v = res.getValue(row, col); cell.setObjectValue(v); if (v != null) {
private String printTable() { StringBuilder sb = new StringBuilder(); int maxWidth = Math.min(MAX_WIDTH, getWidth()); int maxHeight = Math.min(MAX_HEIGHT, getHeight()); int[] width = new int[maxWidth + 1]; for (int i1 = 0; i1 <= maxHeight; i1++) { for (int j1 = 0; j1 <= maxWidth; j1++) { width[j1] = Math.max(width[j1], getStringValue(j1, i1).length()); } } for (int i = 0; i <= maxHeight; i++) { for (int j = 0; j <= maxWidth; j++) { if (j != 0) { sb.append(" | "); } String cell = getStringValue(j, i); sb.append(cell); for (int k = 0; k < width[j] - cell.length(); k++) { sb.append(' '); } } sb.append('\n'); } if (getWidth() > MAX_WIDTH || getHeight() > MAX_HEIGHT) { sb.append("... TRUNCATED TABLE ..."); } return sb.toString(); }
String columnName = extractor.getColumn().getColumnName(); int columnIndex = SpreadsheetResultHelper.getColumnIndexByName(columnName, spreadsheetResult.getColumnNames()); Object columnValue = spreadsheetResult.getValue(rowIndex, columnIndex); Object v = extractor.convertAndStoreData(columnValue, rowInstance); if (convertationMetadata != null && v != null) { rowInstance.setStepName(spreadsheetResult.getRowName(rowIndex));
/** * Converts the spreadsheet result to flat structure. * * @param spreadsheetResult {@link SpreadsheetResult} that is going to be * converted. * @return converted result, represented in flat structure. */ public List<CalculationStep> process(SpreadsheetResult spreadsheetResult) { List<CalculationStep> steps = new ArrayList<CalculationStep>(); if (spreadsheetResult != null) { int height = spreadsheetResult.getHeight(); RowFilter rowFilter = conf.buildRowFilter(); for (int row = 0; row < height; row++) { if (rowFilter == null || !rowFilter.excludeRow(spreadsheetResult.getRowName(row))) { CalculationStep step = processRow(spreadsheetResult, row); if (step != null){ steps.add(step); } } } return steps; } if (log.isWarnEnabled()){ log.warn("Spreadsheet result is null"); } return steps; }
private static Map<String, Point> getAbsoluteSpreadsheetFieldCoordinates(SpreadsheetResult spreadsheetResult) { Map<String, Point> absoluteCoordinates = new HashMap<String, Point>(); IGridTable sourceTable = spreadsheetResult.getLogicalTable().getSource(); String[] rowNames = spreadsheetResult.getRowNames(); String[] columnNames = spreadsheetResult.getColumnNames(); for (int i = 0; i < rowNames.length; i++) { for (int j = 0; j < columnNames.length; j++) { int column = getColumn(sourceTable, j); int row = getRow(sourceTable, i); ICell cell = sourceTable.getCell(column, row); Point absolute = new Point(cell.getAbsoluteColumn(), cell.getAbsoluteRow()); StringBuilder sb = new StringBuilder(); sb.append(SpreadsheetStructureBuilder.DOLLAR_SIGN) .append(columnNames[j]) .append(SpreadsheetStructureBuilder.DOLLAR_SIGN) .append(rowNames[i]); absoluteCoordinates.put(sb.toString(), absolute); } } return absoluteCoordinates; }
/** * Converts the spreadsheet result to flat structure. * * @param spreadsheetResult {@link SpreadsheetResult} that is going to be converted. * * @return converted result, represented in flat structure. */ public List<CodeStep> process(SpreadsheetResult spreadsheetResult) { List<CodeStep> steps = new ArrayList<CodeStep>(); if (spreadsheetResult != null) { int height = spreadsheetResult.getHeight(); for (int row = 0; row < height; row++) { CodeStep step = processRow(spreadsheetResult, row); steps.add(step); } return steps; } log.warn("Spreadsheet result is null"); return steps; }
public static boolean isSpreadsheetResult(Object value) { return value != null && value instanceof SpreadsheetResult && ((SpreadsheetResult) value).getLogicalTable() != null; }
public Object makeResult(SpreadsheetResultCalculator result) { Object[][] resultArray = result.getValues(); Spreadsheet spreadsheet = result.getSpreadsheet(); String[] rowNames = spreadsheet.getRowNames(); String[] columnNames = spreadsheet.getColumnNames(); Map<String, Point> fieldsCoordinates = spreadsheet.getFieldsCoordinates(); SpreadsheetResult spreadsheetBean = new SpreadsheetResult(resultArray, rowNames, columnNames, fieldsCoordinates); TableSyntaxNode tsn = spreadsheet.getSyntaxNode(); if (tsn != null) { spreadsheetBean.setLogicalTable(tsn.getTableBody()); } return spreadsheetBean; }
@Override public Object get(Object target, IRuntimeEnv env) { if (target == null) { return getType().nullObject(); } SpreadsheetResult spreadsheetResult = (SpreadsheetResult) target; String name = getName(); if (!spreadsheetResult.hasField(name)) { throw new OpenLRuntimeException(String.format("Field '%s' does not exist in SpreadsheetResult", name)); } Object res = spreadsheetResult.getFieldValue(name); return res != null ? res : getType().nullObject(); }
private CodeStep processRow(SpreadsheetResult spreadsheetResult, int row) { CodeStep step = null; RowExtractor<?> rowExtractor = rowExtractorsFactory .getRowExtractor(anyNestedValueInRow(spreadsheetResult, row)); step = rowExtractor.extract(spreadsheetResult, row); step.setStepName(spreadsheetResult.getRowName(row)); return step; }
public Object get(Object target, IRuntimeEnv env) { if (target == null) { return getType().nullObject(); } Object res = ((SpreadsheetResult) target).getFieldValue(getName()); return res != null ? res : getType().nullObject(); }
public FormattedCell filterFormat(FormattedCell cell) { ILogicalTable table = res.getLogicalTable(); if (row >= 0 && col >= 0 && res.getWidth() > col && res.getHeight() > row) { Object v = res.getValue(row, col); cell.setObjectValue(v); if (v != null) {
/** * Converts the spreadsheet result to flat structure. * * @param spreadsheetResult {@link SpreadsheetResult} that is going to be * converted. * @return converted result, represented in flat structure. */ public List<CodeStep> process(SpreadsheetResult spreadsheetResult) { List<CodeStep> steps = new ArrayList<CodeStep>(); if (spreadsheetResult != null) { int height = spreadsheetResult.getHeight(); for (int row = 0; row < height; row++) { CodeStep step = processRow(spreadsheetResult, row); steps.add(step); } return steps; } log.warn("Spreadsheet result is null"); return steps; }
public static boolean isSpreadsheetResult(Object value) { return value instanceof SpreadsheetResult && ((SpreadsheetResult) value).getLogicalTable() != null; }