Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   * You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  package pt.webdetails.cda.utils;
  
  import java.util.HashMap;
 import java.util.List;
 
 
 import  org.apache.commons.lang.StringUtils;
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 import  org.pentaho.reporting.engine.classic.core.util.TypedTableModel;
Utility class to handle TableModel operations

User: pedro Date: Feb 4, 2010 Time: 12:31:54 PM

 
 public class TableModelUtils
 {
 
   private static final Log logger = LogFactory.getLog(TableModelUtils.class);
   private static final String DT_FILTER = "dtFilter";
   private static final String DT_SEARCHABLE = "dtSearchableColumns";
   
   private static TableModelUtils _instance;

  

Deprecated:
all methods made static
 
   public TableModelUtils()
   {
   }
  
  

Deprecated:
all methods made static
 
   public static synchronized TableModelUtils getInstance()
   {
 
     if ( == null)
     {
        = new TableModelUtils();
     }
 
     return ;
   }
 
 
   public static TableModel postProcessTableModel(final DataAccess dataAccess,
           final QueryOptions queryOptions,
           final TableModel rawTableModelthrows SortExceptionInvalidOutputIndexException
   {
     
     if(rawTableModel == null){
       throw new IllegalArgumentException("Cannot process null table.");
     } 
 	
     // We will:
     //  1. Evaluate Calculated columns
     //  2. Show only the output columns we want;
     //  3. Sort
     //  4. Pagination
 
     TableModel table;
     
     // 1 Evaluate Calculated columns
     table = evaluateCalculatedColumns(dataAccessrawTableModel);
 
     //  2. Show only the output columns we want, filter rows
     List<IntegeroutputIndexes = getOutputIndexes(dataAccessqueryOptionstable);
     DataTableFilter rowFilter = getRowFilter(queryOptionsoutputIndexes);
     table = filterTable(tableoutputIndexesrowFilter);
 
     //  3. Sort
     if (!queryOptions.getSortBy().isEmpty())
     {
       // no action
       table = (new SortTableModel()).doSort(tablequeryOptions.getSortBy());
     }
 
     // Create a metadata-aware table model
 
    final Class<?>[] colTypes = new Class[table.getColumnCount()];
    final String[] colNames = new String[table.getColumnCount()];
    for (int i = 0; i < table.getColumnCount(); i++)
    {
      colTypes[i] = table.getColumnClass(i);
      colNames[i] = table.getColumnName(i);
    }
    final int rowCount = table.getRowCount();
    MetadataTableModel result = new MetadataTableModel(colNamescolTypesrowCount);
    result.setMetadata("totalRows"rowCount);
    for (int r = 0; r < rowCountr++)
    {
      for (int j = 0; j < table.getColumnCount(); j++)
      {
        result.setValueAt(table.getValueAt(rj), rj);
      }
    }
    //  4. Pagination
    return paginateTableModel(resultqueryOptions);
  }


  

Parameters:
dataAccess
rawTableModel
Returns:
  private static TableModel evaluateCalculatedColumns(final DataAccess dataAccessfinal TableModel rawTableModel) {
    TableModel table;
    final ArrayList<ColumnDefinitioncolumnDefinitions = dataAccess.getCalculatedColumns();
    if (columnDefinitions.isEmpty())
    {
      table = rawTableModel;
    }
    else
    {
      table = new CalculatedTableModel(rawTableModelcolumnDefinitions.toArray(new ColumnDefinition[columnDefinitions.size()]), true);
    }
    return table;
  }


  

Parameters:
table
outputIndexes
rowFilter (optional)
Returns:
Throws:
InvalidOutputIndexException
  private static TableModel filterTable(final TableModel tableList<IntegeroutputIndexesfinal DataTableFilter rowFilterthrows InvalidOutputIndexException {
    int columnCount = outputIndexes.size();
    
    if(columnCount == 0 && rowFilter != null)
    {//still have to go through the motions if we need to filter rows
      for(int i=0; i<table.getColumnCount(); i++){
        outputIndexes.add(i);
      }
      columnCount = outputIndexes.size();
    }
    
    if (columnCount != 0)
    {
      if ((Collections.max(outputIndexes) > table.getColumnCount() - 1))
      {
        throw new InvalidOutputIndexException("Output index higher than number of columns in tableModel"null);
      }
      final int rowCount = table.getRowCount();
      .debug(rowCount == 0 ? "No data found" : "Found " + rowCount + " rows");
      final Class<?>[] colTypes = new Class[columnCount];
      final String[] colNames = new String[columnCount];
      //just set the number of rows/columns
      final TypedTableModel typedTableModel = new TypedTableModel(colNamescolTypesrowCount);
      
      for (int rowIn = 0, rowOut = 0; rowIn < rowCountrowIn++, rowOut++)
      {
        //filter rows
        if(rowFilter != null && !rowFilter.rowContainsSearchTerms(tablerowIn)){
          rowOut--;
          continue;
        }
        //filter columns
        for (int j = 0; j < outputIndexes.size(); j++)
        {
          final int outputIndex = outputIndexes.get(j);
          typedTableModel.setValueAt(table.getValueAt(rowInoutputIndex), rowOutj);
        }
      }
      
      //since we set the calculated table model to infer types, they will be available after rows are evaluated
      for (int i = 0; i < outputIndexes.size(); i++)
      {
        final int outputIndex = outputIndexes.get(i);
        typedTableModel.setColumnName(itable.getColumnName(outputIndex));
        typedTableModel.setColumnType(itable.getColumnClass(outputIndex));
      }
      return typedTableModel;
    }
    return table;
  }
  private static DataTableFilter getRowFilter(final QueryOptions queryOptionsfinal List<IntegeroutputIndexes)
  {  
    String filterText = StringUtils.trim(queryOptions.getExtraSettings().get());
    if(!StringUtils.isEmpty(filterText)){
      int[] searchableIndexes = null;
      if(queryOptions.getExtraSettings().containsKey()){
        try{
          String[] unparsedIndexes = StringUtils.split(queryOptions.getExtraSettings().get(), ',');
          searchableIndexes = new int[unparsedIndexes.length];
          if(outputIndexes.size() > 0){
            for(int i=0; isearchableIndexes.lengthi++){
              int idx = Integer.parseInt(unparsedIndexes[i].trim());
              searchableIndexes[i] = outputIndexes.get(idx);
            }
          }
        }
        catch(IndexOutOfBoundsException e){
          .error( + " is out of bounds.");
          searchableIndexes = null;
        }
        catch(NumberFormatException e){
          .error( + " not a comma-separated list of integers: " +  queryOptions.getExtraSettings().get());
          searchableIndexes = null;
        }
      }
      
      if(searchableIndexes == null) {//include all
        searchableIndexes = new int[outputIndexes.size()];
        for(int i=0; isearchableIndexes.lengthi++){
          searchableIndexes[i] = outputIndexes.get(i);
        }
      }
      
      return new DataTableFilter(filterTextsearchableIndexes);
    }
    return null;
  }
  
  
  private static List<IntegergetOutputIndexes(final DataAccess dataAccessfinal QueryOptions queryOptionsTableModel tablethrows InvalidOutputIndexException 
  {
    // First we need to check if there's nothing to do.
    ArrayList<IntegeroutputIndexes = dataAccess.getOutputs(queryOptions.getOutputIndexId());
    if(outputIndexes == null) {
      throw new InvalidOutputIndexException("Invalid outputIndexId: " + queryOptions.getOutputIndexId(), null);
    }
    /*
    if (queryOptions.isPaginate() == false && outputIndexes.isEmpty() && queryOptions.getSortBy().isEmpty())
    {
    // No, the original one is good enough
    return t;
    }
     */
    // 2
    // If output mode == exclude, we need to translate the excluded outputColuns
    // into included ones
    if (dataAccess.getOutputMode(queryOptions.getOutputIndexId()) == .. && outputIndexes.size() > 0)
    {
      ArrayList<IntegernewOutputIndexes = new ArrayList<Integer>();
      for (int i = 0; i < table.getColumnCount(); i++)
      {
        if (!outputIndexes.contains(i))
        {
          newOutputIndexes.add(i);
        }
      }
      outputIndexes = newOutputIndexes;
    }
    return outputIndexes;
  }
  public static TableModel copyTableModel(final DataAccess dataAccessfinal TableModel t)
  {
    // We're removing the ::table-by-index:: cols
    // Build an array of column indexes whose name is different from ::table-by-index::.*
    ArrayList<StringnamedColumns = new ArrayList<String>();
    ArrayList<Class<?>> namedColumnsClasses = new ArrayList<Class<?>>();
    for (int i = 0; i < t.getColumnCount(); i++)
    {
      String colName = t.getColumnName(i);
      if (!colName.startsWith("::table-by-index::")
              && !colName.startsWith("::column::"))
      {
        namedColumns.add(colName);
        namedColumnsClasses.add(t.getColumnClass(i));
      }
    }
    final int count = namedColumns.size();
    final Class<?>[] colTypes = namedColumnsClasses.toArray(new Class[]{});
    final String[] colNames = namedColumns.toArray(new String[]{});
    for (int i = 0; i < counti++)
    {
      colTypes[i] = t.getColumnClass(i);
      final ColumnDefinition col = dataAccess.getColumnDefinition(i);
      colNames[i] = col != null ? col.getName() : t.getColumnName(i);
    }
    final int rowCount = t.getRowCount();
    .debug(rowCount == 0 ? "No data found" : "Found " + rowCount + " rows");
    final TypedTableModel typedTableModel = new TypedTableModel(colNamescolTypesrowCount);
    for (int r = 0; r < rowCountr++)
    {
      for (int c = 0; c < countc++)
      {
        typedTableModel.setValueAt(t.getValueAt(rc), rc);
      }
    }
    return typedTableModel;
  }
  public static TableModel dataAccessMapToTableModel(HashMap<StringDataAccessdataAccessMap)
  {
    int rowCount = dataAccessMap.size();
    // Define names and types
    final String[] colNames =
    {
      "id""name""type"
    };
    final Class<?>[] colTypes =
    {
      String.classString.classString.class
    };
    final TypedTableModel typedTableModel = new TypedTableModel(colNamescolTypesrowCount);
    for (DataAccess dataAccess : dataAccessMap.values())
    {
      if (dataAccess.getAccess() == ..)
      {
        typedTableModel.addRow(new Object[]
                {
                  dataAccess.getId(), dataAccess.getName(), dataAccess.getType()
                });
      }
    }
    return typedTableModel;
  }
  public static TableModel dataAccessParametersToTableModel(final ArrayList<Parameterparameters)
  {
    int rowCount = parameters.size();
    // Define names and types
    final String[] colNames =
    {
      "name""type""defaultValue""pattern""access"
    };
    final Class<?>[] colTypes =
    {
      String.classString.classString.classString.classString.class
    };
    final TypedTableModel typedTableModel = new TypedTableModel(colNamescolTypesrowCount);
    for (Parameter p : parameters)
    {
      typedTableModel.addRow(new Object[]
              {
                p.getName(), p.getTypeAsString(), p.getDefaultValue(), p.getPattern(), p.getAccess().toString()
              });
    }
    return typedTableModel;
  }


  
Method to append a tablemodel into another. We'll make no guarantees about the types

Parameters:
tableModelA TableModel to be modified
tableModelB Contents to be appended #
  public static TableModel appendTableModel(final TableModel tableModelAfinal TableModel tableModelB)
  {
    // We will believe the data is correct - no type checking
    int colCountA = tableModelA.getColumnCount(),
            colCountB = tableModelB.getColumnCount();
    boolean usingA = colCountA > colCountB;
    int colCount = usingA ? colCountA : colCountB;
    TableModel referenceTable = (usingAtableModelA : tableModelB);
    
    final Class<?>[] colTypes = new Class[colCount];
    final String[] colNames = new String[colCount];
    for (int i = 0; i < referenceTable.getColumnCount(); i++)
    {
      colTypes[i] = referenceTable.getColumnClass(i);
      colNames[i] = referenceTable.getColumnName(i);
    }
    int rowCount = tableModelA.getRowCount() + tableModelB.getRowCount();
    // Table A
    final TypedTableModel typedTableModel = new TypedTableModel(colNamescolTypesrowCount);
    for (int r = 0; r < tableModelA.getRowCount(); r++)
    {
      for (int c = 0; c < colTypes.lengthc++)
      {
        typedTableModel.setValueAt(tableModelA.getValueAt(rc), rc);
      }
    }
    // Table B
    int rowCountOffset = tableModelA.getRowCount();
    for (int r = 0; r < tableModelB.getRowCount(); r++)
    {
      for (int c = 0; c < colTypes.lengthc++)
      {
        typedTableModel.setValueAt(tableModelB.getValueAt(rc), r + rowCountOffsetc);
      }
    }
    return typedTableModel;
  }
  private static TableModel paginateTableModel(MetadataTableModel tQueryOptions queryOptions)
  {
    if (!queryOptions.isPaginate() || (queryOptions.getPageSize() == 0 && queryOptions.getPageStart() == 0))
    {
      return t;
    }
    final int rowCount = Math.min(queryOptions.getPageSize(), t.getRowCount() - queryOptions.getPageStart());
    .debug("Paginating " + queryOptions.getPageSize() + " pages from page " + queryOptions.getPageStart());
    final Class<?>[] colTypes = new Class[t.getColumnCount()];
    final String[] colNames = new String[t.getColumnCount()];
    for (int i = 0; i < t.getColumnCount(); i++)
    {
      colTypes[i] = t.getColumnClass(i);
      colNames[i] = t.getColumnName(i);
    }
    final MetadataTableModel resultTableModel = new MetadataTableModel(colNamescolTypesrowCountt.getAllMetadata());
    resultTableModel.setMetadata("pageSize"queryOptions.getPageSize());
    resultTableModel.setMetadata("pageStart"queryOptions.getPageStart());
    for (int r = 0; r < rowCountr++)
    {
      for (int j = 0; j < t.getColumnCount(); j++)
      {
        resultTableModel.setValueAt(t.getValueAt(r + queryOptions.getPageStart(), j), rj);
      }
    }
    return resultTableModel;
  }
New to GrepCode? Check out our FAQ X