private String[] buildArrayForHeaders(Map<Integer, SpreadsheetHeaderDefinition> headers, int size){ String[] ret = new String[size]; for (Entry<Integer, SpreadsheetHeaderDefinition> x : headers.entrySet()){ int k = x.getKey(); ret[k] = x.getValue().getFirstname(); } return ret; }
public String rowOrColumn() { return isRow() ? "row" : "column"; }
private static List<SpreadsheetCell> listNonEmptyCells(SpreadsheetCell[][] cells, SpreadsheetHeaderDefinition definition) { List<SpreadsheetCell> list = new ArrayList<SpreadsheetCell>(); int row = definition.getRow(); int col = definition.getColumn(); if (row >= 0) { for (int i = 0; i < cells[0].length; ++i) { if (!(cells[row][i].isEmpty())) { list.add(cells[row][i]); } } } else { for (int i = 0; i < cells.length; ++i) { if (!(cells[i][col].isEmpty())) { list.add(cells[i][col]); } } } return list; }
private void buildReturnCells(IOpenClass spreadsheetHeaderType) throws SyntaxNodeException { SpreadsheetHeaderDefinition headerDefinition = headerDefinitions.get(SpreadsheetSymbols.RETURN_NAME.toString()); if (headerDefinition == null) { return; } int nonEmptyCellsCount = calculateNonEmptyCells(headerDefinition); IOpenClass cellType = deriveSingleCellReturnType(nonEmptyCellsCount, headerDefinition, spreadsheetHeaderType); if (headerDefinition.getType() == null) { headerDefinition.setType(cellType); } else { String message = String .format( "RETURN %s derives it's type from the Spreadsheet return type and therefore must not be defined here", headerDefinition.rowOrColumn()); throw SyntaxNodeExceptionUtils.createError(message, headerDefinition.getVars().get(0).getName()); } returnHeaderDefinition = new ReturnSpreadsheetHeaderDefinition(headerDefinition, spreadsheetHeaderType); headerDefinitions.put(SpreadsheetSymbols.RETURN_NAME.toString(), returnHeaderDefinition); }
IdentifierNode typeIdentifierNode = null; for (SymbolicTypeDefinition symbolicTypeDefinition : headerDefinition.getVars()) { headerDefinition.setType(headerType); if (!bindingContext.isExecutionMode() && typeIdentifierNode != null) { ILogicalTable cell; if (headerDefinition.getRow() >= 0) { cell = cellsHeaderExtractor.getRowNamesTable().getRow(headerDefinition.getRow()); } else { cell = cellsHeaderExtractor.getColumnNamesTable().getColumn(headerDefinition.getColumn());
private int calculateNonEmptyCells(SpreadsheetHeaderDefinition headerDefinition) { int fromRow = 0; int toRow = cellsHeaderExtractor.getHeight(); int fromColumn = 0; int toColumn = cellsHeaderExtractor.getWidth(); if (headerDefinition.isRow()) { fromRow = headerDefinition.getRow(); toRow = fromRow + 1; } else { fromColumn = headerDefinition.getColumn(); toColumn = fromColumn + 1; } int nonEmptyCellsCount = 0; for (int columnIndex = fromColumn; columnIndex < toColumn; columnIndex++) { for (int rowIndex = fromRow; rowIndex < toRow; rowIndex++) { ILogicalTable cell = LogicalTableHelper.mergeBounds(cellsHeaderExtractor.getRowNamesTable().getRow(rowIndex), cellsHeaderExtractor.getColumnNamesTable().getColumn(columnIndex)); String value = cell.getSource().getCell(0, 0).getStringValue(); if (value != null && value.trim().length() > 0) { nonEmptyCellsCount += 1; } } } return nonEmptyCellsCount; }
private void proc(int rowIndex, ComponentOpenClass rowOpenClass, int columnIndex, SpreadsheetHeaderDefinition columnHeader) { if (columnHeader == null) { return; } SpreadsheetCell cell = cells[rowIndex][columnIndex]; for (SymbolicTypeDefinition typeDefinition : columnHeader.getVars()) { String fieldName = (DOLLAR_SIGN + typeDefinition.getName().getIdentifier()).intern(); SpreadsheetCellField field = createSpreadsheetCellField(rowOpenClass, cell, fieldName); rowOpenClass.addField(field); } }
private void addColumnHeaders() { String[] columnNames = cellsHeaderExtractor.getColumnNames(); for (int i = 0; i < columnNames.length; i++) { if (columnNames[i] != null) { IGridTable columnNameForHeader = cellsHeaderExtractor.getColumnNamesTable().getColumn(i).getRow(0).getSource(); GridCellSourceCodeModule source = new GridCellSourceCodeModule(columnNameForHeader, bindingContext); SpreadsheetHeaderDefinition header = columnHeaders.get(i); if (header == null) { header = new SpreadsheetHeaderDefinition(-1, i); columnHeaders.put(i, header); } parseHeader(header, source); } } }
private void parseHeader(SpreadsheetHeaderDefinition header, IOpenSourceCodeModule source) { SymbolicTypeDefinition parsed = null; try { parsed = parseHeaderElement(source); IdentifierNode name = parsed.getName(); String headerName = name.getIdentifier(); SpreadsheetHeaderDefinition h1 = headerDefinitions.get(headerName); if (h1 != null) { SyntaxNodeException error; error = SyntaxNodeExceptionUtils.createError("The header definition is duplicated", name); addError(error); throw new DuplicatedVarException(null, headerName); } else { headerDefinitions.put(headerName, header); } header.addVarHeader(parsed); } catch (SyntaxNodeException error) { addError(error); } }
/** * Derives single cell return type. * * @param cellsCount spreadsheet cells count * @param headerDefinition spreadsheet header * @return the type that should be in the cell that is located in RETURN row * or column * * Right now we allow only to return types = scalars or arrays. */ private IOpenClass deriveSingleCellReturnType(int cellsCount, SpreadsheetHeaderDefinition headerDefinition, IOpenClass spreadsheetHeaderType) throws SyntaxNodeException { IOpenClass returnType = spreadsheetHeaderType; if (cellsCount < 2) { return returnType; } IAggregateInfo aggregateInfo = returnType.getAggregateInfo(); if (aggregateInfo != null && aggregateInfo.getComponentType(returnType) != null) { returnType = aggregateInfo.getComponentType(returnType); } else { throw SyntaxNodeExceptionUtils.createError( "The return type is scalar, but there are more than one return cells", headerDefinition.findVarDef( SpreadsheetSymbols.RETURN_NAME.toString()).getName()); } return returnType; }
/** * Creates a field from the spreadsheet cell and add it to the spreadsheetType */ private void addSpreadsheetFields(SpreadsheetOpenClass spreadsheetType, SpreadsheetCell spreadsheetCell, int rowIndex, int columnIndex) { SpreadsheetHeaderDefinition columnHeaders = componentsBuilder.getColumnHeaders().get(columnIndex); SpreadsheetHeaderDefinition rowHeaders = componentsBuilder.getRowHeaders().get(rowIndex); if (columnHeaders == null || rowHeaders == null) { return; } for (SymbolicTypeDefinition columnDefinition : columnHeaders.getVars()) { for (SymbolicTypeDefinition rowDefinition : rowHeaders.getVars()) { // get column name from the column definition String columnName = columnDefinition.getName().getIdentifier(); // get row name from the row definition String rowName = rowDefinition.getName().getIdentifier(); // create name of the field String fieldname = getSpreadsheetCellFieldName(columnName, rowName); // create spreadsheet cell field SpreadsheetCellField field = createSpreadsheetCellField(spreadsheetType, spreadsheetCell, fieldname); // add spreadsheet cell field to its open class spreadsheetType.addField(field); } } }
private void addRowHeaders() { String[] rowNames = cellsHeaderExtractor.getRowNames(); for (int i = 0; i < rowNames.length; i++) { if (rowNames[i] != null) { IGridTable rowNameForHeader = cellsHeaderExtractor.getRowNamesTable().getRow(i).getColumn(0).getSource(); IOpenSourceCodeModule source = new GridCellSourceCodeModule(rowNameForHeader, bindingContext); SpreadsheetHeaderDefinition header = rowHeaders.get(i); if (header == null) { header = new SpreadsheetHeaderDefinition(i, -1); rowHeaders.put(i, header); } parseHeader(header, source); } } }
String code = StringUtils.trimToNull(source.getCode()); String name = getSpreadsheetCellFieldName(columnHeaders.get(columnIndex).getFirstname(), rowHeaders.get(rowIndex).getFirstname());