Java tutorial
/* * #%L * data-exporter * %% * Copyright (C) 2012 - 2013 http://www.brsanthu.com * %% * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * #L% */ package com.brsanthu.dataexporter; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.Writer; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; import org.apache.commons.lang3.StringEscapeUtils; import com.brsanthu.dataexporter.model.BeanRow; import com.brsanthu.dataexporter.model.CellDetails; import com.brsanthu.dataexporter.model.Column; import com.brsanthu.dataexporter.model.DataExporterCallback; import com.brsanthu.dataexporter.model.HeaderCellDetails; import com.brsanthu.dataexporter.model.Row; import com.brsanthu.dataexporter.model.RowDetails; import com.brsanthu.dataexporter.model.Table; import com.brsanthu.dataexporter.util.Util; /** * Workhorse of the library, which coordinates and exports the header, rows and footer as * appropriate. This method has list of abstract classes, so called hooks, which subclasses * can make use to write the data at appropriate time. * <p> * Subclasses must extend {@link AbstractDataWriter} instead of this class. * * @author Santhosh Kumar */ public abstract class DataWriter { protected ExportOptions options = null; private PrintWriter out = null; private boolean autoFlush = true; private AtomicInteger rowIndex = new AtomicInteger(); /** * Initializes DataWriter with given export options and output stream * * @param options the options to use during exporting. Cannot be <code>null</code>. * @param out the output stream to write the data to. Cannot be <code>null</code>. */ public DataWriter(ExportOptions options, OutputStream out) { this(options, new OutputStreamWriter(out)); } /** * Initializes the datawriter with given export options and writer. * * @param options the options to use during exporting. Cannot be <code>null</code>. * @param out the output writer to write the data to. Cannot be <code>null</code>. */ public DataWriter(ExportOptions options, Writer out) { Util.checkForNotNull(out, "out"); Util.checkForNotNull(options, "options"); this.options = options; this.out = new PrintWriter(out); } public void setOutputStream(PrintWriter out) { this.out = out; } /** * Returns the currently active options. * * @return the current options */ public ExportOptions getOptions() { return options; } /** * This method could be used to export the given table and rows. * * @param table the table to export to. Cannot be <code>null</code>. * @param rows the list of rows to export to. Cannot be <code>null</code>. */ public void writeTable(Table table, List<Row> rows) { Util.checkForNotNull(rows, "rows"); Util.checkForNotNull(table, "table"); beforeTable(table); writeHeader(table); writeRows(table, rows); afterTable(table); } /** * Writes the given set of rows to the output stream. * * @param table the table. Cannot be <code>null</code>. * @param rows list of rows to write to. Cannot be <code>null</code>. */ public void writeRows(Table table, List<Row> rows) { Util.checkForNotNull(rows, "rows"); Util.checkForNotNull(table, "table"); for (Row row : rows) { RowDetails rowDetails = new RowDetails(table, rowIndex.getAndIncrement(), row); writeRow(rowDetails); } } /** * Writes the header for given table. * * @param table the table whose header needs to be written. Cannot be <code>null</code>. */ public void writeHeader(Table table) { Util.checkForNotNull(table, "table"); if (options.isPrintHeaders() && table.getColumns() != null) { beforeHeaderRow(table); for (int i = 0; i < table.getColumns().size(); i++) { HeaderCellDetails headerCellDetails = new HeaderCellDetails(table, i); beforeHeaderCell(headerCellDetails); writeHeaderCell(headerCellDetails); afterHeaderCell(headerCellDetails); } afterHeaderRow(table); } } /** * Writes the row from given <code>rowDetails</code> * * @param rowDetails the row details of the row being exported. Cannot be <code>null</code>. */ public void writeRow(RowDetails rowDetails) { Util.checkForNotNull(rowDetails, "rowDetails"); //Generate the row data generateRowData(rowDetails); DataExporterCallback callback = rowDetails.getTable().getCallback(); if (callback != null) { callback.beforeRow(rowDetails); } beforeRow(rowDetails); for (int columnIndex = 0; columnIndex < rowDetails.getTable().getColumns().size(); columnIndex++) { CellDetails cellDetails = new CellDetails(rowDetails, columnIndex); cellDetails.setCellValue(rowDetails.getRow().getCellValue(cellDetails)); cellDetails.setCellValue(rowDetails.getRow().getCellValue(cellDetails)); if (callback != null) { callback.beforeCell(cellDetails); } beforeRowCell(cellDetails); writeRowCell(cellDetails); afterRowCell(cellDetails); if (callback != null) { callback.afterCell(cellDetails); } } afterRow(rowDetails); if (callback != null) { callback.afterRow(rowDetails); } } protected void print(char value) { print("" + value); } protected void print(String value) { out.print(options.isEscapeHtml() ? StringEscapeUtils.escapeHtml4(value) : value); if (autoFlush) { out.flush(); } } protected void println(String value) { out.print(options.isEscapeHtml() ? StringEscapeUtils.escapeHtml4(value) : value); println(); if (autoFlush) { out.flush(); } } protected void println() { out.print(options.getLineSeparatorString()); if (autoFlush) { out.flush(); } } public void flush() { out.flush(); } public void finishExporting() { rowIndex = new AtomicInteger(); } /** * Method generates the cell values for columns which generates its own data * and gives a chance for cell override if there is a call back. * * @param rowDetails */ protected void generateRowData(RowDetails rowDetails) { List<Column> columns = rowDetails.getTable().getColumns(); List<Object> cellValues = new ArrayList<Object>(); //If column is configured as 'generates own data', then there would //be less number of cell values in the row. We need to fill those //missing cell values with null before asking call back to generate //the data. This is to make sure column index reference is consistent. int skippedColumns = 0; for (int columnIndex = 0; columnIndex < columns.size(); columnIndex++) { Column column = columns.get(columnIndex); CellDetails cellDetails = new CellDetails(rowDetails, columnIndex - skippedColumns); cellDetails.setColumn(column); if (column.isGeneratesOwnData()) { cellValues.add(null); skippedColumns++; } else { Object cellValue = null; if (rowDetails.getRow() instanceof BeanRow) { BeanRow beanRow = (BeanRow) rowDetails.getRow(); cellValue = beanRow.getCellValue(column.getName()); } else { //If there are less number of cells added to the row than there are columns, //we would assume rest of the cells as nulls. if (rowDetails.getRow().getCellValues().size() > cellDetails.getColumnIndex()) { cellValue = rowDetails.getRow().getCellValue(cellDetails); } } if (cellValue == null) { cellValue = options.getNullString(); } cellValues.add(cellValue); } } rowDetails.getRow().setCellValues(cellValues); //Go ahead and ask the call back to generate the data for such column. //After generating the data, go ahead and ask the callback to override if //applicable. for (int columnIndex = 0; columnIndex < columns.size(); columnIndex++) { CellDetails cellDetails = new CellDetails(rowDetails, columnIndex); Object cellValue = null; Column column = columns.get(columnIndex); if (column.isGeneratesOwnData()) { if (column.getCellValueGenerator() == null) { throw new RuntimeException("Column " + column + " configured as own data generator but callback is not configured."); } cellValue = column.getCellValueGenerator().generateCellValue(cellDetails); } else { cellValue = rowDetails.getRow().getCellValue(cellDetails); } cellDetails.setCellValue(cellValue); rowDetails.getRow().setCellValue(columnIndex, cellValue); } } /** * Hook which would be called before exporting any data. * * @param table the table being exported. */ public abstract void beforeTable(Table table); public abstract void beforeHeaderRow(Table table); public abstract void beforeHeaderCell(HeaderCellDetails headerCell); public abstract void writeHeaderCell(HeaderCellDetails headerCell); public abstract void afterHeaderCell(HeaderCellDetails headerCell); public abstract void afterHeaderRow(Table table); public abstract void beforeRow(RowDetails rowDetails); public abstract void beforeRowCell(CellDetails cellDetails); public abstract void writeRowCell(CellDetails cellDetails); public abstract void afterRowCell(CellDetails cellDetails); public abstract void afterRow(RowDetails rowDetails); public abstract void beforeFooterRow(Table table); // public abstract void beforeFooterCell(FooterCellDetails footerCellDetails); // // public abstract void writeFooterCell(FooterCellDetails footerCellDetails); // // public abstract void afterFooterCell(FooterCellDetails footerCellDetails); public abstract void afterFooterRow(List<Column> columns); public abstract void afterTable(Table table); }